home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Amiga Format CD 37
/
Amiga Format CD37 (1999-02-16)(Future Publishing)(GB)(Track 1 of 3)[!][issue 1999-03].iso
/
-screenplay-
/
shareware
/
invasionforce
/
source
/
includes
/
game_play1.c
< prev
next >
Wrap
C/C++ Source or Header
|
1999-01-09
|
130KB
|
3,519 lines
/*
game_play1.c -- game play module for Invasion Force
This module handles game play: loading and saving games, getting orders
from the user, moving units, handling combat, and presenting various
menus for branching to the status reports, message system, etc.
This source code is free. You may make as many copies as you like.
*/
#include "global.h"
#include <proto/layers.h>
#define CLEAR_WINDOW() SetRast(rast_port,0);zero_scrollers();display=0;
#define EXIT_GAME 1 // kluge values for flow control
#define GAME_OVER 2
#define UNIT_DONE 3 // I mainly use these to break out of nested functions
#define UNIT_LOST 4
#define GO_SURVEY 5
#define EXIT_SURVEY 6
#define GO_MOVEMENT 7
#define END_TURN 8
#define GAME_RESTORED 9
#define GO_PRODUCTION 10
#define CE_RESTART -17
int control_flag = 0; // kluge variable to break out of nested funcs
#define INVISIBLE 0
#define VISIBLE 1 // flag values, purely for more readable code
char game_filepath[108], game_filename[108];
struct Menu *move_menu_strip = NULL;
struct Menu *vey_menu_strip = NULL;
struct Menu *prod_menu_strip = NULL;
int PathCost=0;
struct PLayer roster[9];
int player = 0; // number of the current player
int turn = 0; // current turn number
BOOL display; // current status of player display
int cursx, cursy; // current location of the survey cursor
char id_filetag[5]; // identifies temporary files
struct MinList unit_list; // master list of active game pieces
struct BattleRecord battle;
char *prefix = "T:EMP2."; // prefix for all Invasion force temporary files
// set_display_offsets() will set the xoffs and yoffs values to try and
// center the specified col & row map position as closely as possible
void set_display_offsets(col,row)
{
int overlap=(wrap?WRAP_OVERLAP:0);
int wd=width+2, ht=height+2;
xoffs = col-(disp_wd >> 1);
if (xoffs<(0-overlap))
xoffs = (0-overlap);
if (xoffs>(wd-disp_wd+overlap))
xoffs = (wd-disp_wd+overlap);
yoffs = row-(disp_ht >> 1);
if (yoffs<-overlap)
yoffs = -overlap;
if (yoffs>ht-disp_ht+overlap)
yoffs = ht-disp_ht+overlap;
update_scrollers();
}
/*
count_units_at() -- return number of units at the specified map sector.
The AO can call this function to see how many units he has on a specified
sector, but should only call it for sectors he controls. Using it to see
how many units the enemy has in a sector would be cheating!
*/
int count_units_at(col,row)
int col,row;
{
int ctr = 0;
struct Unit *unit = (struct Unit *)unit_list.mlh_Head;
for (; unit->unode.mln_Succ; unit = (struct Unit *)unit->unode.mln_Succ)
if (unit->col==col && unit->row==row)
ctr++;
return ctr;
}
// this is the case where the player has just seen a city, so we
// must create an icon for it on his map
void add_city_to_player_map(player,metro)
int player;
struct City *metro;
{
struct MapIcon *icon = AllocVec((long)sizeof(*icon),MEMF_CLEAR);
if (icon==NULL) return; // Will this mean Phantom Cities?
// copy basic information
icon->col = metro->col;
icon->row = metro->row;
icon->type = CITY;
icon->owner = metro->owner;
if (metro->owner==player)
icon->stacked = (count_units_at(icon->col,icon->row)>1);
else
icon->stacked = FALSE;
AddTail((struct List *)&PLAYER.icons,(struct Node *)icon);
}
// similar to function above
// adds an icon to the map, this time for a unit
void add_icon_to_player_map(player,unit)
int player;
struct Unit *unit;
{
struct MapIcon *icon = AllocVec((long)sizeof(*icon),MEMF_CLEAR);
if (icon==NULL) return;
// copy basic information
icon->col = unit->col;
icon->row = unit->row;
icon->type = unit->type;
icon->owner = unit->owner;
icon->token = ORDER_NONE;
if (unit->owner==player && unit->orders!=NULL)
icon->token = unit->orders->type;
if (player==unit->owner)
icon->stacked = (count_units_at(icon->col,icon->row)>1);
else
icon->stacked = FALSE;
AddTail((struct List *)&PLAYER.icons,(struct Node *)icon);
}
/*
submarines cannot see land or air units
when a hex is being explored, this function determines whether
a land or air unit is seen either by a sub or by some other adjacent
unit or city; returns TRUE if seen, FALSE otherwise
*/
BOOL seenby_subP(player,targ)
int player;
struct Unit *targ;
{
int col=targ->col, row=targ->row;
int num_hexes=adjacent(col,row);
struct City *metro;
struct Unit *unit;
int ctr;
if (targ->owner==player)
return TRUE;
if (wishbook[targ->type].ship_flag) // subs can always see ships
return TRUE;
// search adjacent hexes for cities or units that can spot the target
for (ctr=0; ctr<num_hexes; ctr++) {
col = hexlist[ctr].col;
row = hexlist[ctr].row;
if (metro = city_hereP(col,row))
if (metro->owner==player)
return TRUE;
for (unit=(struct Unit *)unit_list.mlh_Head;unit->unode.mln_Succ;unit=(struct Unit *)unit->unode.mln_Succ)
if (unit->col==col && unit->row==row && unit->owner==player)
if (unit->type!=SUB)
return TRUE;
OD
return FALSE; // nobody spotted him
}
// determine whether a submarine at the given position is visible
// returns TRUE if the unit "sub" can be seen by any cities or other
// units owned by "player", otherwise FALSE
BOOL sub_seenP(player,sub)
int player; // the player who is exploring
struct Unit *sub;
{
int col=sub->col, row=sub->row;
int terrain=get(t_grid,col,row);
int num_hexes=adjacent(col,row);
struct City *metro;
struct Unit *unit;
int ctr;
if (sub->owner==player)
return TRUE;
if (terrain==HEX_SHALLOWS) // subs always visible in shallow water
return TRUE;
// search adjacent hexes for cities or units that can spot the sub
for (ctr=0; ctr<num_hexes; ctr++) {
col = hexlist[ctr].col;
row = hexlist[ctr].row;
if (metro = city_hereP(col,row))
if (metro->owner==player)
return TRUE;
for (unit=(struct Unit *)unit_list.mlh_Head;unit->unode.mln_Succ;unit=(struct Unit *)unit->unode.mln_Succ)
if (unit->col==col && unit->row==row && unit->owner==player)
if (unit->type==CRUISER || unit->type==DESTROYER || unit->type==SUB)
return TRUE;
OD
return FALSE; // nobody spotted him
}
/*
recon() determines if a given city is vulnerable to recon by the current
player's aircraft (in other words, if the player has a plane in an
adjacent hex to see what the city is producing); if the city is
vulnerable to recon, we will store the production type in city.recon[]
*/
void recon(metro)
struct City *metro;
{
int hexes, ctr;
if (metro==NULL)
return;
if (metro->owner==player || metro->owner==0)
return;
hexes = adjacent(metro->col,metro->row); // build list of adjacent hexes
for (ctr=0;ctr<hexes;ctr++) {
struct Unit *unit = (struct Unit *)unit_list.mlh_Head;
// search this hex for recon aircraft (currently only fighters)
for (;unit->unode.mln_Succ;unit=(struct Unit *)unit->unode.mln_Succ)
if (unit->col==hexlist[ctr].col && unit->row==hexlist[ctr].row)
if (unit->owner==player && unit->type==FIGHTER) {
metro->recon[player] = metro->unit_type;
return;
FI
}
}
// very important -- function to explore a hex for a certain player
void explore_hex(player,col,row,visible,forced)
int player, col, row, visible, forced;
{ // explore an individual hex
// try wrapping the value around onto the map
wrap_coords(&col,&row);
// now see what terrain is here
put(PLAYER.map,col,row,get(t_grid,col,row));
// also roads
if (get_flags(t_grid,col,row)&ROAD)
put_flags(PLAYER.map,col,row,get_flags(PLAYER.map,col,row)|ROAD);
else
put_flags(PLAYER.map,col,row,get_flags(PLAYER.map,col,row)&(~ROAD));
/* clear any outdated icons from the player's map, this position */
{
BOOL zapped;
do {
struct MapIcon *icon = (struct MapIcon *)PLAYER.icons.mlh_Head;
zapped = FALSE;
for (; icon->inode.mln_Succ; icon = (struct MapIcon *)icon->inode.mln_Succ) {
if (icon->col==col && icon->row==row) {
Remove((struct Node *)icon);
FreeVec(icon);
zapped = TRUE;
break;
FI
OD
} while (zapped);
}
// update any city that might be here
{
struct City *metro = (struct City *)city_list.mlh_Head;
for ( ; metro->cnode.mln_Succ; metro = (struct City *)metro->cnode.mln_Succ)
if (metro->col==col && metro->row==row) {
add_city_to_player_map(player,metro);
recon(metro); // try to recon the city
goto eh_final_update; /* don't display military units if a city is here */
FI
}
// finally, search for new up-to-date pieces and map them
{
struct Unit *unit = (struct Unit *)unit_list.mlh_Head;
BOOL mapped=FALSE;
for (; unit->unode.mln_Succ; unit = (struct Unit *)unit->unode.mln_Succ)
if (unit->row==row && unit->col==col) { // found one!
if (unit->owner!=player)
clear_orders(unit); // enemy units come off sentry now
if (unit->ship) continue; /* don't map units on board ships */
if (unit->type==SUB) // subs sometimes not visible, of course
if (sub_seenP(player,unit)==FALSE)
continue;
if (seenby_subP(player,unit)==FALSE && forced==FALSE)
continue;
if (mapped==FALSE) {
mapped = TRUE; // only map the first one
add_icon_to_player_map(player,unit);
FI
FI
}
eh_final_update:
if (visible) //NOTE: this is now a BOOLEAN value!
GP_update_hex_display(col,row);
}
/*
given a hex, explore_at_hex() will explore it and everyplace
directly adjacent -- this is the normal way that exploration happens
in Invasion Force
*/
void explore_at_hex(player,col,row,visible,forced)
int player, col, row, visible, forced;
{ // explore everything in and adjacent to a given hex
explore_hex(player,col,row,visible,forced);
explore_hex(player,col-1,row,visible,forced);
explore_hex(player,col+1,row,visible,forced);
explore_hex(player,col,row-1,visible,forced);
explore_hex(player,col,row+1,visible,forced);
if (row%2) { /* i.e. if it's an odd-numbered column */
explore_hex(player,col+1,row-1,visible,forced);
explore_hex(player,col+1,row+1,visible,forced);
} else {
explore_hex(player,col-1,row-1,visible,forced);
explore_hex(player,col-1,row+1,visible,forced);
FI
}
// gives the city to a player, either his home city at the start of the game,
// or else a city he has conquered with a military unit -- and includes a
// call to examine_city() in the "status.c" module
void conquer_city(taken_city)
struct City *taken_city;
{ // take a city
int prior_owner=taken_city->owner;
BOOL vis=Bool(PLAYER.show&SHOW_GRP); // visibility
/*
When this function is called, the map should *already* be displayed
and scrolled to the proper location, so the city is positioned on the
screen; conquer_city() does NOT do this automatically.
*/
taken_city->owner = player; // city mine now!
// update the map icons for both old and new owners
if (prior_owner!=0) // no prior owner of neutral cities
explore_hex(prior_owner,taken_city->col,taken_city->row,INVISIBLE,TRUE);
explore_at_hex(player,taken_city->col,taken_city->row,vis,TRUE);
if (vis) {
// do this so the user can see which city he is looking at
save_hex_graphics(taken_city->col,taken_city->row,0); // blit the background to a safe place
plot_mapobject(taken_city->col,taken_city->row,MAP_MARKER);
FI
// set production to -1 to show that we will be restarting
// production from zilch
taken_city->unit_type = -1;
taken_city->unit_wip = 0;
if (ISHUMAN(PLAYER.type)) {
// create requester -- let him select production
examine_city(taken_city);
// unmark the city on screen
restore_hex_graphics(taken_city->col,taken_city->row,0);
FI
if (NONHUMAN(PLAYER.type)) {
// we call the computer player version of selecting production
set_automated_production(taken_city);
FI
}
// return the player who controls the specified hex, or 0 if nobody does
int hex_owner(col,row)
int col,row;
{
struct City *metro;
struct Unit *unit=(struct Unit *)unit_list.mlh_Head;
// search the cities
if (metro = city_hereP(col,row))
return (int)metro->owner;
// search the military units
for (; unit->unode.mln_Succ; unit=(struct Unit *)unit->unode.mln_Succ)
if (unit->col==col && unit->row==row)
return (int)unit->owner;
return 0;
}
// quick macro to see if a unit has been killed
#define ALIVE(a) (a->damage<wishbook[a->type].hitpoints)
/***
choose_defender() == select a unit to defend a hex that has come under attack
This is supposed to handle the complexities of combat that were introduced
when I implemented stacking rules, particularly when different kinds of
units are stacked in the hex that is under attack
***/
struct Unit *choose_defender(attacker,targx,targy)
struct Unit *attacker;
int targx, targy;
{
struct Unit *unit, *defender=NULL;
static int aapt[] = { 4, 5, 3, 2, 1, 6, 7, 8, 10, 11, 9, 99, 99 };
static int sapt[] = { 1, 2, 3, 11, 10, 4, 5, 6, 8, 9, 7, 99, 99 };
int *table = sapt;
int priority = 99;
int terrain = get(t_grid,targx,targy);
// first determine if I should use the AAPT or the SAPT
if (attacker->type==FIGHTER)
table = aapt;
for (unit=(struct Unit *)unit_list.mlh_Head;unit->unode.mln_Succ;unit=(struct Unit *)unit->unode.mln_Succ)
if (unit->col==targx && unit->row==targy)
if (table[unit->type]<priority) {
// I have to throw out any ground units that are on board a ship
if (OCEAN_P(terrain) && (unit->type==RIFLE || unit->type==ARMOR))
continue;
// also throw out any fighters that are landed (not overflying)
if (unit->ship)
continue;
defender = unit;
priority = table[unit->type];
FI
if (defender==NULL)
print("ERROR: choose_defender() failed to find defending unit for combat!\n");
return defender;
}
/***
attack_hex() == universal attack function
All attacks in the game are targetted against a hex, not against specific
enemy units. This function calculates the defensive strength of the target
hex and resolves the conflict. The outcome is stored in "control_flag" and
in the combat report.
***/
void attack_hex(attacker,targx,targy)
struct Unit *attacker;
int targx, targy;
{
int att_player=attacker->owner, def_player=0;// attacking and defending players
int def_terrain;
int attfact, deffact, movement_cost;
struct Unit *defender=NULL;
struct Unit militia;
BOOL bombardment=FALSE;
BOOL white_flag=FALSE;
ULONG num_blows, bit_blows;
struct City *captured=NULL;
clear_orders(attacker); // just to make sure
/*
First part of this function is devoted to detecting various kinds of
invalid attacks and weeding them out before we get to the good stuff.
*/
// has the unit already attacked something this turn?
// fighters can make multiple attacks per turn; other cannot
// I have disabled this until I get a beter idea how it should work
// if (attacker->type!=FIGHTER && attacker->attacks>0) {
// tell_user2("That unit has already attacked once this turn.",FALSE,DONK_SOUND);
// return; // other units cannot
// FI
if (city_hereP(targx,targy))
switch (attacker->type) {
case BOMBER: // bomber can attack city, but not capture it
bombardment = TRUE;
case ARMOR:
case RIFLE:
case AIRCAV:
break; // these units can attack cities
default: // other units cannot
if (PLAYER.show&SHOW_REQ) {
playSound(DONK_SOUND,PLAYER.snd_vol);
alert(map_window,"Information...","That unit cannot attack a city.","Okay");
}
return;
};
// bombers and aircav cannot attack any hex containing airborne craft
// aircraft on carriers or in cities or airfields are not considered airborne
if (attacker->type==BOMBER || attacker->type==AIRCAV)
if (city_hereP(targx,targy)==NULL) {
struct Unit *unit = (struct Unit *)unit_list.mlh_Head;
for (;unit->unode.mln_Succ;unit=(struct Unit *)unit->unode.mln_Succ)
if (unit->ship==NULL && unit->col==targx && unit->row==targy)
switch (unit->type) {
case FIGHTER:
case BOMBER:
case AIRCAV:
if (PLAYER.show&SHOW_REQ) {
playSound(DONK_SOUND,PLAYER.snd_vol);
alert(map_window,"Information...","Bombers or air cav cannot attack other aircraft.","Okay");
}
return;
}
FI
def_terrain = get(t_grid,targx,targy);
if (city_hereP(targx,targy)) {
def_terrain = HEX_CITY;
// create a dummy "militia unit" to defend the city
militia.col = targx;
militia.row = targy;
militia.owner = city_hereP(targx,targy)->owner;
militia.type = RIFLE;
militia.damage = 0;
militia.orders = NULL;
defender = &militia;
def_player = city_hereP(targx,targy)->owner;
// set flag to show we are using a militia unit
white_flag = TRUE;
};
/* find the defending UNIT in the hex -- the unit we are using to */
/* determine the defender's strength, etc. */
if (defender==NULL)
defender = choose_defender(attacker,targx,targy);
if (defender) {
clear_orders(defender); // just to make sure
if( def_player == 0 )
def_player = defender->owner;
} else {
print("Error finding defender for combat!\n");
return;
FI
// when a fighter attacks a hex containing both aircraft and other units,
// I set the bombardment flag to show the fighter should not enter the
// hex, even if victorious
if (attacker->type==FIGHTER) {
BOOL air=FALSE, surface=FALSE;
struct Unit *unit;
for (unit=(struct Unit *)unit_list.mlh_Head;unit->unode.mln_Succ;unit=(struct Unit *)unit->unode.mln_Succ)
if (unit->col==targx && unit->row==targy) {
if (wishbook[unit->type].range>0) // aircraft
air=TRUE;
else
surface=TRUE;
if (air==TRUE && surface==TRUE) {
bombardment = TRUE;
break;
FI
FI
FI
// most ships cannot attack ground forces; only cruisers and battleships can
if (movement_cost_table[attacker->type][def_terrain]<0)
switch (attacker->type) {
case TRANSPORT:
case SUB:
case DESTROYER:
case CARRIER:
if (PLAYER.show&SHOW_REQ) {
playSound(DONK_SOUND,PLAYER.snd_vol);
sprintf(foo,"The %s cannot bombard land targets.",
wishbook[attacker->type].name);
(void)rtEZRequestTags(foo,"Oops!",NULL,NULL,
RT_Window, map_window,
RT_ReqPos, REQPOS_CENTERSCR,
RT_LockWindow, TRUE,
RTEZ_Flags, EZREQF_CENTERTEXT,
TAG_DONE );
}
return;
case CRUISER:
case BATTLESHIP:
bombardment = TRUE;
}
// riflemen or armor can bombard ships unless aircraft are protecting them
if (OCEAN_P(def_terrain))
if (attacker->type==RIFLE || attacker->type==ARMOR) {
/*
At this point we might have ground forces trying to attack something
in a HEX_SHALLOWS terrain with a bridge over it.
Otherwise the ground forces must be trying to bombard an ocean hex.
This would mean it's attacking a hex with ships or aircraft or both.
*/
BOOL ship_here=FALSE, aircraft_here=FALSE, bridge_here=FALSE;
struct Unit *sunit;
// check for roads first
if (get_flags(t_grid,attacker->col,attacker->row)& \
get_flags(t_grid,defender->col,defender->row)&ROAD)
bridge_here = TRUE;
for (sunit=(struct Unit *)unit_list.mlh_Head;sunit->unode.mln_Succ;sunit=(struct Unit *)sunit->unode.mln_Succ)
if (wishbook[sunit->type].ship_flag && sunit->col==targx && sunit->row==targy) {
ship_here = TRUE;
break;
FI
for (sunit=(struct Unit *)unit_list.mlh_Head;sunit->unode.mln_Succ;sunit=(struct Unit *)sunit->unode.mln_Succ)
if (wishbook[sunit->type].range>0 && sunit->col==targx && sunit->row==targy) {
aircraft_here = TRUE;
break;
FI
/*
There are three possibilities for the target ocean hex. It could have
ships, aircraft, or both ships and aircraft. Each calls for a slightly
different response.
*/
if (aircraft_here && ship_here) {
if (PLAYER.show & SHOW_REQ) {
playSound(DONK_SOUND,PLAYER.snd_vol);
(void)rtEZRequestTags(\
"Enemy air cover prevents your ground forces\nfrom bombarding ships there.",
"Drat!",NULL,NULL,
RT_Window, map_window,
RT_ReqPos, REQPOS_CENTERSCR,
RT_LockWindow, TRUE,
RTEZ_Flags, EZREQF_CENTERTEXT,
TAG_DONE );
}
return;
FI
if (aircraft_here) {
if (PLAYER.show & SHOW_REQ) {
playSound(DONK_SOUND,PLAYER.snd_vol);
(void)rtEZRequestTags(\
"Ground forces cannot attack aircraft that are over water.",
"Drat!",NULL,NULL,
RT_Window, map_window,
RT_ReqPos, REQPOS_CENTERSCR,
RT_LockWindow, TRUE,
RTEZ_Flags, EZREQF_CENTERTEXT,
TAG_DONE );
}
return;
FI
// if weve made it this far, there must only be ships
if (wishbook[defender->type].ship_flag)
bombardment = TRUE;
FI
// determine whether the attacking unit has enough movement value left
// to carry out the assault, i.e. enough to enter the enemy hex area
if (def_terrain==HEX_CITY || bombardment==TRUE)
movement_cost = 60;
else
movement_cost = movement_cost_table[attacker->type][def_terrain];
if (movement_cost < attacker->move) {
attacker->move -= movement_cost;
if (attacker->move<11) {
attacker->move = 0;
control_flag = UNIT_DONE;
}
} else { // he only has enough movement for a /chance/ at this
int chance = attacker->move;
attacker->move = 0;
control_flag = UNIT_DONE;
if (RangeRand(movement_cost)>chance) {
if( PLAYER.soundfx == SOUND_ALL ) {
// Only play the sound if the player wants stuff shown
playSound(SMASH_SOUND,PLAYER.snd_vol);
}
return; // his movement attempt failed
FI
}
/*
Bombardment, in the context of this game, means that a unit is attacking
a hex area that it cannot move onto, such as a cruiser firing upon rifle
units. The only difference between bombardment and normal combat is that
the victorious attacking unit does not move.
*/
/*
Now we take time out to initialize and record basic information
into the structure for the combat report.
*/
battle.turn = turn;
battle.att_x = attacker->col;
battle.att_y = attacker->row;
battle.att_owner = attacker->owner;
battle.att_type = attacker->type;
battle.def_x = defender->col;
battle.def_y = defender->row;
battle.def_owner = defender->owner;
battle.white_icon = white_flag;
battle.def_type = defender->type;
battle.winner = 0;
battle.casualties = 0;
battle.bombardment = bombardment;
// always seen by defender; we can add others flags later
battle.seen_by = mask(battle.def_owner);
battle.blows = 0L;
// track number of attacks made by this unit
attacker->attacks++;
// move the unit
if (bombardment==FALSE) {
attacker->col = targx;
attacker->row = targy;
FI
// keep survey mode up to date
cursx = attacker->col; cursy = attacker->row;
if (attacker->ship) { // he must be attacking from on board a ship
attacker->ship->cargo--;
attacker->ship->weight -= cargo_weight(attacker->type);
if (attacker->ship->type==TRANSPORT)
attacker->move = 0; // unloading from a transport expends movement
attacker->ship=NULL; // so we unlink him from it
FI
if (attacker->type==TRANSPORT && attacker->cargo>0) { // ship moves, cargo moves
struct Unit *cargo=(struct Unit *)unit_list.mlh_Head;
for (; cargo->unode.mln_Succ; cargo=(struct Unit *)cargo->unode.mln_Succ)
if (cargo->ship==attacker) {
cargo->col=targx; cargo->row=targy;
clear_orders(cargo);
}
}
if (wishbook[attacker->type].range>0) // units that need fuel, i.e. aircraft
attacker->fuel--;
/*
This function looks at an attacking unit and a defending unit and adds up
various modifiers based on the types of units, the terrain, the handicap
of the players, etc. It sticks the results in attfact and deffact.
*/
NCS_combat_mods(attacker,defender,&attfact,&deffact);
/*
battle actually takes place; calculate attacks, damage
record combat reports, display battle action and sounds
NOTE: battle always begins with two visible blows that have no game
effect, but serve to establish visually who is attacking who
*/
num_blows = 2L; bit_blows = 2L;
while (ALIVE(attacker) && ALIVE(defender)) {
int attval, defval;
static int strength[] = { 1, 1, 1, 2, 1, 1, 3, 1, 2, 3, 1, 1 };
/*
strength is the amount of damage done by a hit from the unit
infantry --- 1
armor ------ 1
aircav ----- 1
bomber ----- 2
fighter ---- 1
transport -- 1
sub -------- 3
destroyer -- 1
cruiser ---- 2
battleship - 3
carrier ---- 1
*/
/*
Here is the NCS (New Combat System) which is based on simulated roll of
three six-sided dice (3d6) for each player.
attval = 3d6 + attfact
defval = 3d6 + deffact
And whoever's total is higher wins the round of combat.
*/
do {
attval = 3 + RangeRand(6L) + RangeRand(6L) + RangeRand(6L) + attfact;
defval = 3 + RangeRand(6L) + RangeRand(6L) + RangeRand(6L) + deffact;
} while (attval==defval); // we don't allow draws
if (num_blows<24L) {
num_blows++;
bit_blows <<= 1; // make way for the bit
if (attval>defval)
bit_blows |= 1L; // this bit shows who was hit
FI
if (attval>defval)
defender->damage += strength[attacker->type];
else {
attacker->damage += strength[defender->type];
/*
If the attacker is a ship, and it's taken enough damage to slow its
speed, then I want to go back and retro-actively reduce its rate for
THIS turn. In other words, if my destroyer (speed 3) attacks on its
first move of this turn, and it takes two points of damage, it's
speed should be *immediately* reduced to one -- and that one has
already been expended in the attack!
*/
if (unit_speed(attacker)<wishbook[attacker->type].speed)
attacker->move = 0;
FI
OD
battle.blows = (num_blows<<24) | bit_blows;
if (ALIVE(defender)) { // defeat first; its easier
if (attacker->ship) { // he could be attacking from on board a ship!
attacker->ship->cargo--;
attacker->ship->weight -= cargo_weight(attacker->type);
FI
Remove((struct Node *)attacker);
// increment Units Lost in Combat
roster[attacker->owner].ulc[attacker->type]++;
roster[defender->owner].eud[attacker->type]++;
control_flag = UNIT_LOST;
/* record the event for posterity */
battle.winner = battle.def_owner;
} else { // victory here
// go down the list for defending units to destroy
// we must do multiple searches, because destroying a unit messes
// up the list structure
BOOL unit_found;
struct Unit *unit;
do {
unit_found = FALSE;
for (unit=(struct Unit *)unit_list.mlh_Head;unit->unode.mln_Succ;unit=(struct Unit *)unit->unode.mln_Succ)
if (unit->col==targx && unit->row==targy && unit->owner!=attacker->owner) {
if (attacker->type==FIGHTER && bombardment==TRUE)
if (wishbook[unit->type].range<=0) // not an aircraft
continue;
Remove((struct Node *)unit);
roster[unit->owner].ulc[unit->type]++; // inc. Units Lost in Combat
roster[attacker->owner].eud[unit->type]++; // inc. Enemy Units Destroyed
battle.casualties++;
destruct_unit(unit);
unit_found = TRUE;
break;
FI
} while (unit_found);
// if theres a city here, attacker conquers it
captured = city_hereP(targx,targy);
if (captured)
if (captured->owner) // a non-neutral city is taken
battle.seen_by |= mask(captured->owner);
if (captured!=NULL && bombardment==FALSE) {
// attacking unit is dispersed to hold the city
Remove((struct Node *)attacker);
roster[attacker->owner].ulc[attacker->type]++; // inc. Units Lost in Combat
control_flag = UNIT_LOST;
FI
battle.winner = battle.att_owner;
FI
// display the battle
if (PLAYER.show & SHOW_GRP) show_battle();
if (captured!=NULL && bombardment==FALSE)
conquer_city(captured);
// BSH 1/10 - Removed the check for human player -
// always call conquer_city - it checks inside
// for human player and calls AI when needed
// clean up some things left over after movement & battle
if (control_flag!=UNIT_LOST)
if (wishbook[attacker->type].range>0 && attacker->fuel<=0) {
// aircraft out of fuel, crashes
Remove((struct Node *)attacker);
roster[attacker->owner].ulc[attacker->type]++;
control_flag = UNIT_LOST;
FI
if (control_flag==UNIT_LOST)
destruct_unit(attacker); // destruct and free RAM
{
BOOL vis=Bool(roster[att_player].show&SHOW_GRP);
explore_at_hex(att_player,targx,targy,vis,TRUE);
}
if (def_player>0) // neutral cities never explore
explore_at_hex(def_player,targx,targy,INVISIBLE,TRUE);
if (control_flag!=UNIT_LOST)
if (roster[attacker->owner].show & SHOW_GRP)
unit_status_bar(attacker);
{ // write the combat report file
BPTR outfile;
strcpy(foo,prefix);
strcat(foo,id_filetag);
strcat(foo,".CR");
if (outfile = Open(foo,MODE_OLDFILE)) {
Seek(outfile,0L,OFFSET_END);
Write(outfile,&battle,sizeof(battle));
Close(outfile);
FI
}
}
/*
This is part of the NCS (New Combat System).
This NCS function will accept the information about a combat event and
calculate the attack and defense modifiers for both units -- taking into
account unit types, terrain, stacking, and the global handicap values of
the two players.
*/
void NCS_combat_mods(attacker, defender, att_mod, def_mod)
struct Unit *attacker, *defender;
int *att_mod, *def_mod;
{
int terrain = get(t_grid,defender->col,defender->row);
int atype = attacker->type;
int dtype = defender->type;
// I can do this shortcut because airfields defend like infantry in
// every respect; of course it is only changed locally in this function!
if (dtype==AIRFIELD)
dtype = RIFLE;
// start with the global handicap values of the players
*att_mod = roster[attacker->owner].att;
*def_mod = roster[defender->owner].def;
// transports always have a -4 on defense
if (dtype==TRANSPORT)
*def_mod -= 4;
// transports and carriers have a -4 on attack
if (atype==TRANSPORT || atype==CARRIER)
*att_mod -= 4;
// carriers have a -2 defense and -1 for every 2 fighters on board
if (dtype==CARRIER) {
*def_mod -= 2;
{ // count units on board
int ctr = 0;
struct Unit *unit = (struct Unit *)unit_list.mlh_Head;
for (; unit->unode.mln_Succ; unit = (struct Unit *)unit->unode.mln_Succ)
if (unit->ship==defender) ctr++;
*def_mod -= ctr/2;
}
}
// submarines have a basic -3 defense
if (dtype==SUB)
*def_mod -= 3;
// fighters & bombers have a +3 defending against ships
if (dtype==FIGHTER || dtype==BOMBER)
if (wishbook[atype].ship_flag)
*def_mod += 3;
// fighters have a +3 attack against bombers or aircav
if (dtype==BOMBER || dtype==AIRCAV)
if (atype==FIGHTER)
*att_mod += 3;
/*
ground units defending:
-3 against naval bombardment
-2 against bombers
-1 against other aircraft
*/
if (dtype==RIFLE || dtype==ARMOR) {
switch (dtype) {
case CRUISER:
case BATTLESHIP:
*def_mod--;
case BOMBER:
*def_mod--;
case FIGHTER:
case AIRCAV:
*def_mod--;
}
}
/* That takes care of the unit-based modifiers. Now the terrain stuff! */
switch (terrain) {
case HEX_DESERT:
// ground forces -2 defense against aircraft
if (dtype==RIFLE || dtype==ARMOR)
if (wishbook[atype].range>0)
*def_mod -= 2;
// infantry -2 defense against armor
if (dtype==RIFLE && atype==ARMOR)
*def_mod -= 2;
break;
case HEX_BRUSH:
// ground forces +1 defense against fighters or bombers
if (dtype==RIFLE || dtype==ARMOR)
if (atype==FIGHTER || atype==BOMBER)
*def_mod++;
break;
case HEX_FOREST:
// ground forces +2 defense against fighters or bombers
if (dtype==RIFLE || dtype==ARMOR)
if (atype==FIGHTER || atype==BOMBER)
*def_mod += 2;
// infantry +2 defense against armor
if (dtype==RIFLE && atype==ARMOR)
*def_mod += 2;
// armor -2 defense against infantry
if (dtype==ARMOR && atype==RIFLE)
*def_mod -= 2;
break;
case HEX_JUNGLE:
// ground forces +3 defense against fighters or bombers
if (dtype==RIFLE || dtype==ARMOR)
if (atype==FIGHTER || atype==BOMBER)
*def_mod += 3;
// infantry +3 defense against armor
if (dtype==RIFLE && atype==ARMOR)
*def_mod += 3;
// armor -3 defense against infantry
if (dtype==ARMOR && atype==RIFLE)
*def_mod -= 3;
break;
case HEX_SWAMP:
// ground forces +1 defense against aircraft
if (dtype==RIFLE || dtype==ARMOR)
if (wishbook[atype].range>0)
*def_mod++;
// infantry +2 defense against armor shelling
if (dtype==RIFLE && atype==ARMOR)
*def_mod += 2;
break;
case HEX_RUGGED:
// ground forces, +1 defending against fighter or bomber
if (dtype==RIFLE || dtype==ARMOR)
if (atype==FIGHTER || atype==BOMBER)
*def_mod++;
break;
case HEX_HILLS:
// ground forces, +2 defending against fighter or bomber
// ground forces, +1 defending against cruiser or battleship
if (dtype==RIFLE || dtype==ARMOR) {
if (atype==FIGHTER || atype==BOMBER)
*def_mod += 2;
if (atype==CRUISER || atype==BATTLESHIP)
*def_mod += 1;
}
break;
case HEX_MOUNTAINS:
// ground forces, +3 defending against fighter or bomber
// ground forces, +2 defending against air cavalry
// ground forces, +2 defending against cruiser or battleship
if (dtype==RIFLE || dtype==ARMOR) {
if (atype==FIGHTER || atype==BOMBER)
*def_mod += 3;
if (atype==AIRCAV)
*def_mod += 2;
if (atype==CRUISER || atype==BATTLESHIP)
*def_mod += 2;
}
// infantry defending +3 against armor shelling
if (dtype==RIFLE && atype==ARMOR)
*def_mod += 3;
break;
case HEX_SHALLOWS:
// subs attack -3 against ships
if (atype==SUB && wishbook[dtype].ship_flag)
*att_mod -= 3;
// subs defend -2 (on top of the -3 they already have!)
if (dtype==SUB)
*def_mod -= 2;
// all other ships defend at -1 in shallows
if (wishbook[dtype].ship_flag && dtype!=SUB)
*def_mod--;
break;
case HEX_DEPTH:
// sub defends at +3 in depths
if (dtype==SUB)
*def_mod += 3;
break;
}
}
/* This routine determines the basic attack values. I'm just passing in
values instead of unit pointers so I can use this later for the AI
player(s) to do "what if" scenarios and determine what is risky/not
risky attack.
*/
void get_attack_values ( short att_type, int att_terrain, int att_player,
short def_type, int def_terrain, int def_player,
int* attfact, int* deffact)
{
/*was attfact = 100; */
// Now we use the attack factor from the start game setting for the player
*attfact = roster[att_player].att;
if (att_type==TRANSPORT || att_type==CARRIER)
*attfact /= 2;
/*was deffact = 100; */
// Now we use the defense factor from the start game settings
*deffact = roster[def_player].def;
if (def_type==TRANSPORT || def_type==SUB)
*deffact *= 6/10;
if (def_type==RIFLE && (att_type==CRUISER || att_type==BATTLESHIP))
*deffact *= 6/10;
if (def_type==BOMBER && att_type==FIGHTER)
*deffact *= 6/10;
// terrain effects modify attack and defense factors
switch (att_type) {
case ARMOR:
case BOMBER:
if (def_terrain==HEX_DESERT)
*attfact += 25;
break;
case AIRCAV:
if (def_terrain==HEX_FOREST)
*attfact += 10;
if (def_terrain==HEX_JUNGLE)
*attfact += 20;
break;
}
if (def_type==RIFLE) {
if (def_terrain==HEX_FOREST)
*deffact += 10;
if (def_terrain==HEX_JUNGLE)
*deffact += 20;
}
// altitude affects odds between ground units (never ships or planes)
if (att_type==RIFLE || att_type==ARMOR)
if (def_type==RIFLE || def_type==ARMOR) {
switch (att_terrain) {
case HEX_MOUNTAINS: // these are cumulative
*attfact += 10; // neat, huh?
case HEX_HILLS:
*attfact += 10;
case HEX_RUGGED:
*attfact += 10;
}
switch (def_terrain) {
case HEX_MOUNTAINS:
*deffact += 10;
case HEX_HILLS:
*deffact += 10;
case HEX_RUGGED:
*deffact += 10;
}
FI
/* End if */
}
// this is where each player starts the game; it selects the home city, sets
// initial production, etc.
// Broken up into two routines so that the player will not be surprised
void create_initial_city()
{ // put a player on the map!
struct City *home_city; /* this player's starting city */
// STEP ONE: locate a home city for him
do {
struct City *metro = (struct City *)city_list.mlh_Head;
long num_cities = count_nodes(&city_list);
int home_city_index = RangeRand(num_cities)+1;
int ctr;
for ( ctr = 1; metro->cnode.mln_Succ; metro = (struct City *)metro->cnode.mln_Succ, ctr++)
if (ctr == home_city_index) {
home_city = metro;
break;
FI
} while (home_city->owner); /* make sure it's a neutral city */
// Make him the owner
home_city->owner = player;
return;
}
void jumpstart_player()
{
/* Find the player's home city */
struct City* metro = (struct City*)city_list.mlh_Head;
while( (metro->cnode.mln_Succ) && (metro->owner != player) )
metro = (struct City*)metro->cnode.mln_Succ;
// create his map display, all spaces unknown
if (alloc_map(&PLAYER.map)==FALSE)
clean_exit(2,"ERROR: Fatal RAM allocation disaster!\n");
// put his city and surrounding area on the map
explore_at_hex(player,metro->col,metro->row,INVISIBLE,TRUE);
// If File-Mail play create passwords
//if(fmail)
// create_passlock();
// call him to the console and show the map
create_player_display(metro->col,metro->row);
// initialize his city production
conquer_city(metro);
}
void unit_name_request(metro,unit)
struct City *metro;
struct Unit *unit;
{
BOOL exam=FALSE, ship=wishbook[unit->type].ship_flag;
char *name;
struct Window *name_window=NULL;
struct Gadget *context, *name_gad, *cont_gad, *prod_gad;
struct NewGadget button = {
77,66, // leftedge, topedge
98,16, // width, height
"_Continue", // text label
NULL, // font
1, // gadget ID
NULL,NULL,NULL
}, strfield = {
173,40, // leftedge, topedge
200,16, // width, height
"Ship _Name:", // text label
NULL, // font
3, // gadget ID
PLACETEXT_LEFT,
NULL,NULL
};
/* make sure user doesn't play with the map window now */
SetPointer(map_window,BUSY_POINTER);
ModifyIDCMP(map_window,NULL);
// create the [Continue] and [Production] buttons
if (!CreateContext(&context))
clean_exit(1,"Unable to create context gadget!");
button.ng_VisualInfo = vi;
button.ng_TextAttr = &topaz11bold;
cont_gad = CreateGadget(BUTTON_KIND,context,&button,
GT_Underscore, '_',
TAG_END);
button.ng_LeftEdge = 221;
button.ng_GadgetText = "_Production";
button.ng_TextAttr = &topaz11;
button.ng_Flags = NULL;
prod_gad = CreateGadget(BUTTON_KIND,cont_gad,&button,
GT_Underscore, '_',
TAG_END);
// randomly select a name for this unit
name = random_name(unit->type);
// create the name field
strfield.ng_VisualInfo = vi;
strfield.ng_TextAttr = &topaz11;
if (ship)
name_gad = CreateGadget(STRING_KIND,prod_gad,&strfield,
GTST_String, name,
GTST_MaxChars, 19L,
STRINGA_Justification, GACT_STRINGCENTER,
GT_Underscore, '_',
TAG_END);
// do the window itself
{
int x, y, wd=414, ht=88;
// I need to do some pixelly math to figure out the most
// aesthetically pleasing place to put the requester
// It must be near the city in question, yet not hide it from view.
log_to_abs(metro->col,metro->row,&x,&y);
x -= 30;
y += 45;
if (y>map_window->Height-ht)
y -= (90+ht);
name_window = OpenWindowTags(NULL,
WA_Gadgets, context,
WA_Title, "New unit produced...",
WA_CustomScreen, map_screen,
WA_Top,y, WA_Left,x,
WA_Height,ht, WA_Width,wd,
WA_IDCMP, IDCMP_GADGETUP|IDCMP_VANILLAKEY,
WA_Flags, NOCAREREFRESH|WFLG_DRAGBAR|WFLG_ACTIVATE,
TAG_END );
}
if (name_window==NULL)
clean_exit(1,"ERROR: Unable to open production requester!");
// render in some text and a little picture
rast_port = name_window->RPort;
sprintf(foo,"%s produced a %s.",metro->name,wishbook[unit->type].name);
plot_text(10,21,foo,BLACK,LT_GRAY,JAM2,&topaz11);
px_plot_icon(unit->type,45,39,PLAYER.color,0,FALSE);
if (!ship) {
sprintf(foo,"%s %s",name,wishbook[unit->type].name);
plot_text(125,43,foo,BLACK,LT_GRAY,JAM2,&topaz11);
FI
{ // handle the user actions here
struct IntuiMessage *message; // the message the IDCMP sends us
// useful for interpreting IDCMP messages
UWORD code;
ULONG class;
APTR object;
UWORD qualifier;
FOREVER {
WaitPort(name_window->UserPort);
while (message = GT_GetIMsg(name_window->UserPort)) {
code = message->Code; // MENUNUM
object = message->IAddress; // Gadget
class = message->Class;
qualifier = message->Qualifier;
GT_ReplyIMsg(message);
if (class==IDCMP_VANILLAKEY) {
switch ((char)code) {
case 13:
case 'c': // default for CONTINUE
// show the button depressed
show_depress(cont_gad,name_window->RPort);
Delay(10L);
goto exit_name_window;
case 'p': // default for PRODUCTION
show_depress(prod_gad,name_window->RPort);
Delay(10L);
exam = TRUE;
goto exit_name_window;
case 'n': // activate the NAME string
ActivateGadget(name_gad,name_window,NULL);
}
FI
if (class==IDCMP_GADGETUP) {
if (object==cont_gad) {
goto exit_name_window;
FI
if (object==prod_gad) {
exam = TRUE;
goto exit_name_window;
FI
FI
OD
OD
}
exit_name_window:
// fetch new name string from the gadget
if (ship)
name_unit(unit,((struct StringInfo *)name_gad->SpecialInfo)->Buffer);
else
name_unit(unit,name);
// now close up everything with the mapsize_window
CloseWindow(name_window);
rast_port = map_window->RPort;
name_window = NULL;
FreeGadgets(context);
ClearPointer(map_window);
ModifyIDCMP(map_window,IDCMP_PLAYGAME);
if (exam)
examine_city(metro);
}
// go through the production of all cities owned by the current player, and
// do this turn's production of military units, etc.
// it returns the number of units produced
int do_cities_production()
{
struct City *metro = (struct City *)city_list.mlh_Head;
int ctr = 0;
/*
The map wasn't updating correctly sometimes, so I decided to make
two passes on the city list. Now it goes through the list once to
update the WIP and the map area around the cities, then a second
pass for actual production of units.
*/
for( ; metro->cnode.mln_Succ; metro=(struct City*)metro->cnode.mln_Succ)
if( metro->owner == player) {
metro->unit_wip += (metro->industry*PLAYER.prod)/50;
explore_at_hex(player,metro->col,metro->row,INVISIBLE,TRUE);
}
metro = (struct City*)city_list.mlh_Head;
for ( ; metro->cnode.mln_Succ; metro = (struct City *)metro->cnode.mln_Succ)
if (metro->owner==player) {
if (metro->unit_wip >= wishbook[metro->unit_type].build) {
struct Unit *new_unit = AllocVec((int)sizeof(*new_unit),MEMF_CLEAR);
metro->unit_wip = 0;
// build the unit
new_unit->col = metro->col;
new_unit->row = metro->row;
new_unit->owner = player;
new_unit->type = metro->unit_type;
new_unit->move = unit_speed(new_unit);
new_unit->damage = 0;
// Added by BSH
new_unit->attacks = 0;
new_unit->cargo = 0;
new_unit->ship = NULL;
new_unit->orders = NULL;
// End Added BSH
new_unit->fuel = wishbook[new_unit->type].range;
name_unit(new_unit,"UNNAMED");
AddTail((struct List *)&unit_list,(struct Node *)new_unit);
ctr++;
// now inform the user and let him reset the production
if (wishbook[new_unit->type].ship_flag || PLAYER.show_production) {
if (display==FALSE)
create_player_display(metro->col,metro->row);
if (need_to_scrollP(metro->col,metro->row)) {
int ox=xoffs, oy=yoffs;
set_display_offsets(metro->col,metro->row);
GP_smart_scroll(ox,oy);
FI
// do this so the user can see which city he is looking at
save_hex_graphics(metro->col,metro->row,0); // blit the background to a safe place
plot_mapobject(metro->col,metro->row,MAP_MARKER);
unit_name_request(metro,new_unit);
// unmark the city on screen
GP_update_hex_display(metro->col,metro->row);
FI
FI
FI
return ctr;
}
void unit_status_bar(unit)
struct Unit *unit;
{
char foo2[30];
/*
With ships, the unit type goes first, like for example...
Battleship Texas
...but with other units the name goes first, then the type...
101st Infantry
*/
if (wishbook[unit->type].ship_flag)
sprintf(foo,"%s %s",wishbook[unit->type].name,unit->name);
else
sprintf(foo,"%s %s",unit->name,wishbook[unit->type].name);
if (wishbook[unit->type].hitpoints>1) {
sprintf(bar," hits:%ld/%ld",unit->damage,wishbook[unit->type].hitpoints);
strcat(foo,bar);
FI
if (wishbook[unit->type].range>0) {
sprintf(bar," fuel:%ld/%ld",unit->fuel,wishbook[unit->type].range);
strcat(foo,bar);
FI
if (unit->type==TRANSPORT || unit->type==CARRIER) {
sprintf(bar," cargo:%ld/%ld",unit->cargo,(unit->type==TRANSPORT)?6:8);
strcat(foo,bar);
FI
if (unit->orders)
switch (unit->orders->type) {
case ORDER_LOAD:
strcat(foo," orders: Load Ship");
break;
case ORDER_SENTRY:
strcat(foo," orders: Sentry Duty");
break;
case ORDER_FORTIFY:
strcat(foo," orders: Dig In");
break;
case ORDER_UNLOAD:
strcat(foo," status: Unloading Units");
break;
case ORDER_FORTIFIED:
strcat(foo," status: In Fortified Position");
break;
case ORDER_GOTO:
if( !unit->orders->dest_unit ) {
if( unit->orders->etc >= 0 ) {
strcat(foo," orders: Goto Hex: ");
sprintf(foo2, "%ld, %ld", unit->orders->destx,
unit->orders->desty);
strcat(foo, foo2);
}
else {
strcat(foo," orders: Patrol Between: ");
sprintf(foo2, "%ld, %ld and %ld, %ld",
unit->orders->destx, unit->orders->desty,
unit->orders->orgx, unit->orders->orgy);
strcat(foo, foo2);
}
}
else {
strcat(foo," orders: Rendevous with Ship: ");
if( AI3_AssertUnit( unit->orders->dest_unit ) )
strcat(foo, unit->orders->dest_unit->name);
}
break;
} // end switch
strncpy(win_title,foo,79L);
SetWindowTitles(map_window,win_title,(UBYTE *)~0);
// now do the unit movement bar
{
int barleft, barright;
int bartop, barbottom, barheight;
int amplitude, ctr;
InstallClipRegion(map_window->WLayer,bar_region);
SetRast(rast_port,BLACK);
// preliminary calculations before I do the graphics
bartop = map_window->BorderTop+4;
barbottom = map_window->Height-map_window->BorderBottom-15;
barleft = map_window->BorderLeft+4;
barright = barleft+5;
barheight = barbottom-bartop+1;
amplitude = (unit->move*barheight)/wishbook[unit->type].speed;
// draw the green color bar
SetAPen(rast_port,GREEN);
if (wishbook[unit->type].range>0) // i.e. an aircraft
SetAPen(rast_port,LT_BLUE);
if (wishbook[unit->type].ship_flag)
SetAPen(rast_port,DK_BLUE);
RectFill(rast_port,barleft,barbottom-amplitude,barright,barbottom);
// draw the graduation markers
SetAPen(rast_port,WHITE);
for (ctr=0; ctr<=wishbook[unit->type].speed; ctr+=60) {
amplitude = (ctr*barheight)/wishbook[unit->type].speed;
Move(rast_port,barleft,barbottom-amplitude);
Draw(rast_port,barright,barbottom-amplitude);
OD
InstallClipRegion(map_window->WLayer,map_region);
}
}
void hex_status_bar(col,row)
int col, row;
{
struct Unit *unit;
struct MapIcon *icon;
struct City *metro;
// static char *terrain[]={
// "Unexplored Area",
// "Forbidden",
// "Plains",
// "Desert",
// "Scrubland",
// "Forest",
// "Jungle",
// "Rough Country",
// "Hills",
// "Mountains",
// "Mountain Peaks",
// "Swamp",
// "Shallow Waters",
// "Ocean",
// "Deep Ocean",
// "Pack Ice"
//};
clear_movebar();
// look for a city
if (metro=city_hereP(col,row)) {
strncpy(win_title,metro->name,79L);
SetWindowTitles(map_window,win_title,(UBYTE *)~0);
return;
FI
// look for FRIENDLY units (units on ships dont count)
for (unit = (struct Unit *)unit_list.mlh_Head; unit->unode.mln_Succ; unit = (struct Unit *)unit->unode.mln_Succ)
if (unit->col==col && unit->row==row)
if (unit->owner==player && unit->ship==NULL) {
// unit belongs to me; let unit_status_bar() handle it
unit_status_bar(unit);
return;
FI
// look for HOSTILE units
for (icon=(struct MapIcon *)PLAYER.icons.mlh_Head;icon->inode.mln_Succ;icon=(struct MapIcon *)icon->inode.mln_Succ)
if (icon->col==col && icon->row==row && icon->owner!=player) {
sprintf(foo,"HOSTILE: %s's %s",roster[icon->owner].name,wishbook[icon->type].name);
strncpy(win_title,foo,79L);
SetWindowTitles(map_window,win_title,(UBYTE *)~0);
return;
FI
strncpy(win_title,terrain_name_table[get(PLAYER.map,col,row)],79L);
SetWindowTitles(map_window,win_title,(UBYTE *)~0);
}
/*
unit "cargo" is attempting to load onto a transport or carrier at this
location; note that there may be multiple ships in this hex; we must
try to find one that can accept the unit
The return value is TRUE if a suitable ship was found. This does not
mean the ship was actually boarded, because it may have been full.
The calling function should check the cargo->ship value to find out.
*/
BOOL board_ship(cargo,col,row)
struct Unit *cargo;
int col, row;
{
struct Unit *ship=NULL;
int shiptype=NULL;
BOOL result = FALSE;
int weight=cargo_weight(cargo->type);
// determine what kind of ship we need to look for: TRANSPORT for ground
// units, or CARRIER for aircraft
switch (cargo->type) {
case ARMOR:
case RIFLE:
shiptype=TRANSPORT;
break;
case FIGHTER:
// case BOMBER:
// case AIRCAV:
shiptype=CARRIER;
break;
default:
return result;
};
/*
search for ships of the appropriate type in this hex
we don't need to check who they belong to, the hex must be friendly
or this function wouldn't have been called (I hope!)
*/
ship=(struct Unit *)unit_list.mlh_Head;
for (; ship->unode.mln_Succ; ship=(struct Unit *)ship->unode.mln_Succ)
if (ship->type==shiptype && ship->col==col && ship->row==row) {
result = TRUE;
// see if there is room on the ship to accept this unit
if (weight<=cargo_capacity(ship)-ship->weight) {
ship->cargo++; // take up a cargo slot on the ship
ship->weight += weight;
cargo->ship=ship; /* set the cargo unit's new location */
cargo->col=ship->col; cargo->row=ship->row;
cargo->move=0; /* cargo unit's movement this turn is expended */
if (shiptype==TRANSPORT)
give_orders(cargo,ORDER_SENTRY,0,0,-1); // auto-sentry them
if (shiptype==CARRIER)
cargo->fuel = wishbook[cargo->type].range; // refuel aircraft
control_flag=UNIT_DONE; // so that movement_mode() will know
// if this ship is under orders to load units and is now full,
// then we should clear the orders for it, like so...
if (ship->orders)
if (ship->orders->type==ORDER_LOAD && ship->weight>=cargo_capacity(ship))
clear_orders(ship);
explore_at_hex(player,col,row,VISIBLE,FALSE); // update map
return result;
FI
FI
return result;
}
/*
This function determines the cargo capacity of a ship. It returns the
maximum number of units the ship can carry in its current condition
(taking damage into account), NOT the amount of free space on the ship.
Depending on the value you want, use the formulas:
free_space=cargo_capacity(ship)-ship->cargo;
or
free_space=cargo_capacity(ship)-ship->weight; // taking heavy armor into account
The function also returns a -1 if the unit specified is not a cargo vessel,
so it can be used to quickly check that as well.
*/
int cargo_capacity(ship)
struct Unit *ship;
{
int capacity;
switch (ship->type) {
case TRANSPORT:
capacity = 6;
break;
case CARRIER:
capacity = 8;
break;
default:
return -1;
}
capacity -= ship->damage*2; // each hit reduces capacity by two units
return capacity;
}
/*
This function returns the weight (for loading/unloading purposes) of a given
type of cargo. It appears simple to the point of redundancy right now, but it
could easily become more complex as the stacking & transporting rules are
tinkered with.
*/
int cargo_weight(type)
int type;
{
int weight;
switch (type) {
case RIFLE:
case FIGHTER:
weight = 1;
break;
case ARMOR:
weight = 2;
break;
default:
weight = 100; // an impossibly high value
}
return weight;
}
/*
When a ship has been given ORDER_LOAD, it should be referred here. This
function will search for loadable cargo units in the same hex (as in a
city, for example) or in surrounding hexes and attempt to load them on
the ship. When the ship is filled, load_ship() will clear its
orders. Until that happens, however, load_ship() should be called every
turn for it.
*/
void load_ship(ship)
struct Unit *ship;
{
struct Unit *cargo;
int numhexes = adjacent(ship->col,ship->row);
int index, access;
int units_loaded=0, weight;
BOOL valid_cargo;
if (cargo_capacity(ship)<0)
return; // not a cargo vessel
if (ship->cargo>=cargo_capacity(ship) || ship->weight>=cargo_capacity(ship)) {
clear_orders(ship); // ship already full; clear orders
return;
}
// this gives me an index of all hexes I can load units from
hexlist[numhexes++].col = ship->col;
hexlist[numhexes++].row = ship->row;
cargo = (struct Unit *)unit_list.mlh_Head;
for (;cargo->unode.mln_Succ;cargo=(struct Unit *)cargo->unode.mln_Succ)
if (unit_readiness(cargo)&UNIT_READY) {
// search to see if its in an accessible hex
access = FALSE;
for (index=numhexes;index>=0;index--)
if (cargo->col==hexlist[index].col && cargo->row==hexlist[index].row)
access = TRUE;
if (access==FALSE)
continue; // too far away; try next unit
if (cargo->ship)
continue; // unit is already on a ship!
// try to determine whether this is the right kind of cargo
if (ship->type==TRANSPORT)
valid_cargo = (cargo->type==RIFLE || cargo->type==ARMOR);
else
valid_cargo = (cargo->type==FIGHTER); // only fighters in v0.14+
// valid_cargo = (wishbook[cargo->type].range>0);
// see if armor is too heavy
weight = cargo_weight(cargo->type);
if (cargo_capacity(ship)-ship->weight < weight)
valid_cargo = FALSE;
if (valid_cargo) {
units_loaded++;
clear_orders(cargo);
cargo->move = 0; // loading expends movement
cargo->ship = ship;
cargo->col = ship->col;
cargo->row = ship->row;
if (ship->type==TRANSPORT)
give_orders(cargo,ORDER_SENTRY,0,0,-1);
ship->cargo++;
ship->weight += weight;
if (ship->cargo>=cargo_capacity(ship) || ship->weight>=cargo_capacity(ship)) {
clear_orders(ship);
break;
FI
FI
FI
if (units_loaded>0) {
if (PLAYER.show&SHOW_GRP)
explore_at_hex(player,ship->col,ship->row,VISIBLE,FALSE);
if (PLAYER.show&SHOW_REQ) {
sprintf(foo,"Your %s %s has taken on board %ld units.",
wishbook[ship->type].name, ship->name, units_loaded);
if (ship->cargo>=cargo_capacity(ship)) {
sprintf(bar,"\nThe ship is now fully loaded.");
strcat(foo,bar);
FI
(void)rtEZRequestTags(foo,"Okay",NULL,NULL,
RT_Window, map_window,
RT_ReqPos, REQPOS_CENTERSCR,
RT_LockWindow, TRUE,
RTEZ_Flags, EZREQF_CENTERTEXT,
TAG_DONE );
FI
FI
}
/* When a unit has been given the GOTO order it will move
towards the hex recorded in it's orders, clear it's
orders if it hits any impediment (move result = -1),
check when it reaches it's destination, and turn
around and head back if it is doing a PATROL order.
Of course it may have died moving, so we need to do all
checks at the beginning of the routine.
*/
void do_goto( struct Unit* unit )
{
int result;
char foo[128];
if( unit->orders->dest_unit ) {
if( !AI3_AssertUnit( unit->orders->dest_unit ) ) {
clear_orders( unit );
return;
}
AI5_CalcPath( unit->type, unit->col, unit->row,
unit->orders->dest_unit->col,
unit->orders->dest_unit->row, AI5_PATH_GOOD );
// Check our fuel supply
if( (wishbook[unit->type].range > 0) && (unit->fuel < PathLength) ) {
clear_orders( unit );
return;
}
}
else {
AI5_CalcPath( unit->type, unit->col, unit->row,
unit->orders->destx, unit->orders->desty, AI5_PATH_GOOD );
// Check our fuel supply
if( (wishbook[unit->type].range > 0) && (unit->fuel < PathLength) ) {
clear_orders( unit );
return;
}
}
if( Path[0] == -1 ) {
// No path! Or we got there already.
clear_orders( unit );
return;
}
else {
while( (unit->move > 0) && (unit->orders) && (Path[0] != -1) ) {
result = move_unit_dir( unit, Path[0] );
// Check if we couldn't move, missed a chance, attacked a unit
// or city, etc.
if( result <= -1 ) return;
// Else we did move and nothing bad happened, so let's look.
if( unit->orders ) {
if( !unit->orders->dest_unit ) {
if( (unit->col == unit->orders->destx) &&
(unit->row == unit->orders->desty) ) {
// We reached a destination
if( unit->orders->etc >= 0 ) {
// Simple GOTO
clear_orders( unit );
return;
}
else {
// Patrol order - swap 'em.
short temp = unit->orders->destx;
unit->orders->destx = unit->orders->orgx;
unit->orders->orgx = temp;
temp = unit->orders->desty;
unit->orders->desty = unit->orders->orgy;
unit->orders->orgy = temp;
//return;
// Calculate a new path BACK.
AI5_CalcPath( unit->type, unit->col, unit->row,
unit->orders->destx,
unit->orders->desty, AI5_PATH_GOOD );
}
} // End if we arrived
else {
// Create a new path for the next loop
AI5_CalcPath( unit->type, unit->col, unit->row,
unit->orders->destx,
unit->orders->desty, AI5_PATH_GOOD );
// Check our fuel supply
if( (wishbook[unit->type].range > 0) &&
(unit->fuel < PathLength) ) {
clear_orders( unit );
return;
}
// Check our path, see if it got longer
if( unit->orders->etc > 0 ) {
unit->orders->etc--;
if( PathLength - unit->orders->etc > 3 ) {
// we have a major obstacle
if( unit->name ) {
sprintf
(foo,
"Major obstacle detected for %s %s\nmoving from %ld to %ld",
UnitString[unit->type],
unit->name,
unit->col, unit->row,
unit->orders->destx,
unit->orders->desty);
} // End if unit->name
else {
sprintf
(foo,
"Major obstacle detected for %s\nmoving from %ld to %ld",
UnitString[unit->type],
unit->col, unit->row,
unit->orders->destx,
unit->orders->desty);
} // End else no unit->name
if( rtEZRequestTags
(foo,
"Clear Orders|Continue Anyway",
NULL,NULL,
RT_Window, map_window,
RT_ReqPos, REQPOS_CENTERSCR,
RT_LockWindow, TRUE,
RTEZ_Flags, EZREQF_CENTERTEXT,
TAG_DONE ) ) {
clear_orders( unit );
} // End if user wants to clear orders
} // End if major obstacle
} // End if unit->orders->etc >=0
} // End else we have not yet arrived
} // End if not a goto-unit
else {
if( AI3_AssertUnit( unit->orders->dest_unit ) ) {
// check for reaching our destination unit
if( (unit->col == unit->orders->dest_unit->col) &&
(unit->row == unit->orders->dest_unit->row) ) {
clear_orders(unit);
return;
}
else {
// Create a new path for the next loop
AI5_CalcPath( unit->type, unit->col, unit->row,
unit->orders->dest_unit->col,
unit->orders->dest_unit->row,
AI5_PATH_GOOD );
// Check our fuel supply
if( (wishbook[unit->type].range > 0) &&
(unit->fuel < PathLength) ) {
clear_orders( unit );
return;
}
// Check our path, see if it got longer
if( unit->orders->etc > 0 ) {
unit->orders->etc--;
if( PathLength - unit->orders->etc > 3 ) {
// we have a major obstacle
if( unit->name ) {
sprintf
(foo,
"Major obstacle detected for %s %s\nmoving from %ld to %ld",
UnitString[unit->type],
unit->name,
unit->col, unit->row,
unit->orders->destx,
unit->orders->desty);
} // End if unit->name
else {
sprintf
(foo,
"Major obstacle detected for %s\nmoving from %ld to %ld",
UnitString[unit->type],
unit->col, unit->row,
unit->orders->destx,
unit->orders->desty);
} // End else no unit->name
if( rtEZRequestTags
(foo,
"Clear Orders|Continue Anyway",
NULL,NULL,
RT_Window, map_window,
RT_ReqPos, REQPOS_CENTERSCR,
RT_LockWindow, TRUE,
RTEZ_Flags, EZREQF_CENTERTEXT,
TAG_DONE ) ) {
clear_orders( unit );
}
} // End if major obstacle
} // end if unit->orders->etc >= 0
} // End else we did not reach our destination unit
}// end if we still HAVE a destination unit
} // end else we are trying to reach a unit not a location
} // End if we still have orders
}// end while
} // end else we have a path.
return;
}
// this is where a unit is moving on the map, checking all the movment
// rules, possible combat and such as we go
int move_unit_dir(unit,dir)
struct Unit *unit;
enum Direction dir;
{
int targx = unit->col, targy = unit->row;
switch (dir) {
case EAST:
targx++;
break;
case WEST:
targx--;
break;
case NORTHEAST:
targy--;
if (unit->row%2) // odd number
targx++;
break;
case NORTHWEST:
targy--;
if (!(unit->row%2)) // even number
targx--;
break;
case SOUTHEAST:
targy++;
if (unit->row%2) // odd number
targx++;
break;
case SOUTHWEST:
targy++;
if (!(unit->row%2)) // even number
targx--;
break;
default:
return (-8);
}
return (move_unit_xy(unit,targx,targy));
}
int move_unit_xy(unit,targx,targy)
struct Unit *unit;
int targx, targy;
{
//BSH
// This routine will now return integer values for results
// -6 - Attack on City (successful - but still lose unit)
// -5 - Attack on City (failed)
// -4 - Attack on enemy unit(s) (failed)
// -3 - Unit ran out of fuel and crashed
// -2 - Unit failed to move this turn (missed chance)
// -1 - Unit cannot move to target hex
// 0 - Move occurred
// 1 - Moved - Attacked enemy unit(s) (won)
// 2 - Moved - Overflew carrier
// 3 - Moved - Boarded ship
// 4 - Unit moved, but unit(s) on board were lost
// To use the unit over again, check for return > -3
BOOL cargo_killed=FALSE;
int terrain, movement_cost=(-1);
struct City *city=city_hereP(targx,targy); // so I don't call it over and over
// correct values for wrap, if it's active
if (wrap) {
if (targx<0)
targx += width;
if (targx>=width)
targx -= width;
if (targy<0)
targy += height;
if (targy>=height)
targy -= height;
}
/* he certainly can't move off the map! */
// ************* Adding disable for non-users ***************
if (targx<0 || targx>=width || targy<0 || targy>=height) {
if (PLAYER.show & SHOW_REQ)
tell_user2("You cannot move off the map.",FALSE,DONK_SOUND);
return (-1);
FI
/***
Now I want to branch out. I already know the user is trying to move
a unit onto another hex. I need to analyze the contents of that hex
and see if he is attacking a city, attacking an enemy unit, boarding
a ship, or just maneuvering normally. I will branch out to various
functions for each of these cases, except maneuvering which I can
handle here.
***/
// check for a destination city
if (city)
if (city->owner==player) /* it's his own city */
goto normal_movement;
else {
// if this unit can attack a city
attack_hex(unit,targx,targy); // attacking another city
if ((unit->type == ARMOR) || (unit->type == RIFLE) || (unit->type == AIRCAV) || (unit->type == BOMBER)) {
if (hex_owner(targx, targy)!=player)
return -5;
else
return -6;
} else
return -1;
}
// check for hostile military units to attack
{
struct Unit *target = (struct Unit *)unit_list.mlh_Head;
for (; target->unode.mln_Succ; target=(struct Unit *)target->unode.mln_Succ)
if (target->col==targx && target->row==targy && target->owner!=player) {
attack_hex(unit,targx,targy);
if (hex_owner(targx, targy)!=player)
return (-4);
else
return 1;
FI
}
// check for friendly ship to board
if (board_ship(unit,targx,targy)) {
if (unit->ship==NULL) { /* i.e. if unit failed to board the ship */
/* if it's an aircraft, ask if they want to overfly the hex anyhow */
if (wishbook[unit->type].range>0) {
int choice;
// If we have a human, ask him
if (PLAYER.show & SHOW_REQ) {
if(PLAYER.soundfx == SOUND_ALL)
playSound(DONK_SOUND,PLAYER.snd_vol);
choice = rtEZRequestTags(\
"The carrier cannot accept your unit.\nDo you wish to overfly it?",
"Overfly|Abort", NULL, NULL,
RT_Window, map_window,
RT_ReqPos, REQPOS_CENTERSCR,
RT_LockWindow, TRUE,
RT_ShareIDCMP, TRUE,
RTEZ_Flags, EZREQF_CENTERTEXT,
TAG_DONE );
}
// Otherwise, just do the overfly
else choice = 1;
if (choice==0) return (-1);
} else {
if (PLAYER.show & SHOW_REQ)
tell_user2("No ship in that hex can accept your troops.",FALSE,DONK_SOUND);
return (-1);
FI
} else // unit successfully boarded the ship
return (3);
FI
normal_movement:
// check to see if stacking rules allow him to enter this hex
if (opt.stacking==FALSE && city==NULL) {
BOOL valid = TRUE;
struct Unit *target = (struct Unit *)unit_list.mlh_Head;
for (; target->unode.mln_Succ; target=(struct Unit *)target->unode.mln_Succ)
if (target->col==targx && target->row==targy) {
int weight=cargo_weight(unit->type);
valid = FALSE;
if (unit->type==ARMOR || unit->type==RIFLE)
if (target->type==TRANSPORT && target->weight<=(cargo_capacity(target)-weight)) {
valid = TRUE;
break;
FI
if (wishbook[unit->type].range>0) // aircraft
if (target->type==CARRIER && target->weight<(cargo_capacity(target)-weight)) {
valid = TRUE;
break;
FI
FI
if (valid==FALSE) { // cannot enter this hex
if (PLAYER.show & SHOW_REQ)
tell_user2("Your unit cannot stack in that hex.",FALSE,DONK_SOUND);
return (-1);
FI
FI
terrain = get(t_grid,targx,targy);
movement_cost = movement_cost_table[unit->type][terrain];
if (city)
movement_cost = 10; // always easy to enter a friendly city!
// is he on the road?
if (unit->type==RIFLE || unit->type==ARMOR)
if (get_flags(t_grid,unit->col,unit->row)&get_flags(t_grid,targx,targy)&ROAD)
movement_cost = 30;
if (terrain==HEX_FORBID) { /* Just in case a road is here! *ELS* */
if (PLAYER.show & SHOW_REQ)
tell_user2("Your unit cannot traverse that kind of terrain.",FALSE,DONK_SOUND);
return (-1);
FI
if (movement_cost<0) { /* it must be a terrain this unit can't traverse */
if (PLAYER.show & SHOW_REQ)
tell_user2("Your unit cannot traverse that kind of terrain.",FALSE,DONK_SOUND);
return (-1);
FI
if (city)
movement_cost = 10; // yes, even if there is a road here
if (unit->ship)
movement_cost = 60; // this is always true when unloading from a ship
/* if a unit's remaining movement points drop to 10 or less (which is 1/6 of
** a "standard" one hex move, then I round it down to zero; this is also the
** minimum for attacking, loading onto ships, entering cities, etc.
*/
if (movement_cost<unit->move) { // he definitely has enough movement for this
unit->move -= movement_cost;
if (unit->move<10) {
unit->move = 0;
control_flag = UNIT_DONE;
FI
} else { // he only has enough movement for a /chance/ at this
int chance = unit->move;
unit->move = 0;
control_flag = UNIT_DONE;
if (RangeRand(movement_cost)>chance) {
//BSH
if (PLAYER.soundfx == SOUND_ALL)
playSound(SMASH_SOUND,PLAYER.snd_vol);
return (-2); // his movement attempt failed
FI
FI
// follow him with scrolling, if necessary
//BSH
if (PLAYER.show & SHOW_GRP) {
if (need_to_scrollP(targx,targy)) {
int ox = xoffs, oy = yoffs;
set_display_offsets(targx,targy);
GP_smart_scroll(ox,oy);
FI
// animated movement
anim_move(unit,unit->col,unit->row,targx,targy);
FI
// move the unit
unit->col = targx;
unit->row = targy;
if (unit->ship) { // he must be unloading from a ship
unit->ship->cargo--;
unit->ship->weight -= cargo_weight(unit->type);
if (unit->ship->type==TRANSPORT) {
unit->move = 0; // unloading from a transport expends movement
control_flag = UNIT_DONE;
FI
unit->ship=NULL; // so we unlink him from it
FI
if (unit->cargo>0) { // ship moves, cargo moves
int ctr, capacity, num_hexes=adjacent(targx,targy);
struct Unit *cargo; BOOL unsentry=FALSE;
/*
If the ship has been damaged, it may no longer be able to carry all
the troops or aircraft on board it. If that is the case, here is
where we kill off the extra ones, when the ship moves. Of course,
they can survive if the ship has just moved into a city!
*/
capacity = 6;
if (unit->type==CARRIER)
capacity = 8;
capacity -= unit->damage*2;
/*
kill units until capacity == cargo
multiple searches may be required because the destruction of units
messes up the list structure
*/
ctr = 0;
while (unit->cargo>capacity)
for (cargo=(struct Unit *)unit_list.mlh_Head;cargo->unode.mln_Succ;cargo=(struct Unit *)cargo->unode.mln_Succ)
if (cargo->ship==unit) {
unit->cargo--;
if (city) // cargo is merely unloaded into the city
cargo->ship = NULL;
else { // cargo is lost at sea
ctr++;
Remove((struct Node *)cargo);
destruct_unit(cargo);
break;
FI
FI
if (ctr) {
cargo_killed = TRUE;
if (PLAYER.show & SHOW_REQ) {
// I must tell the user the bad news! Number of units lost == ctr.
sprintf(foo,"Because of battle damage, the ship is overloaded.\nYou lost %ld cargo to the sea!",ctr);
(void)rtEZRequestTags(foo,
"Drat!",NULL,NULL,
RT_Window, map_window,
RT_ReqPos, REQPOS_CENTERSCR,
RT_LockWindow, TRUE,
RTEZ_Flags, EZREQF_CENTERTEXT,
TAG_DONE );
FI
FI
/*
Find out if there is a hostile unit or city, or neutral city
in a hex adjacent to this one; if so, un-sentry RIFLE, ARMOR or AIRCAV.
The "unsentry" flag will determine this.
*/
for (ctr=0; ctr<num_hexes; ctr++) {
int owner=hex_owner(hexlist[ctr].col,hexlist[ctr].row);
struct City *metro=city_hereP(hexlist[ctr].col,hexlist[ctr].row);
if (owner>0 && owner!=player)
unsentry=TRUE;
if (metro) // check for neutral cities
if (metro->owner!=player)
unsentry=TRUE;
OD
for (cargo=(struct Unit *)unit_list.mlh_Head;cargo->unode.mln_Succ;cargo=(struct Unit *)cargo->unode.mln_Succ)
if (cargo->ship==unit) {
cargo->col=targx; cargo->row=targy;
if (unsentry)
switch (cargo->type) {
case RIFLE:
case ARMOR:
case AIRCAV:
clear_orders(cargo);
}
FI
FI
// units entering into cities get repaired
if (city) {
if (unit->damage>0)
unit->damage--;
unit->move = 0;
control_flag = UNIT_DONE;
FI
if (wishbook[unit->type].range>0) { // units that need fuel, i.e. aircraft
if( unit->ship == NULL ) unit->fuel--; // Added this if statement here,
// was just unit->fuel--, trying to fix bug where aircraft on carrier
// lose fuel as carrier moves.
if (city) { // refuel
unit->fuel = wishbook[unit->type].range;
unit->move = 0; /* after entering a city, the plane's turn is over */
control_flag = UNIT_DONE;
FI
if (unit->fuel<=0) {
// aircraft out of fuel, crashes!
if (PLAYER.show & SHOW_REQ) {
plot_mapobject(targx,targy,154,30); // draw explosion
context_sound(BOOM_SOUND); // kaboomy!
// now tell the player the awful news
sprintf(foo,"Your %s has run out of fuel and crashed!",wishbook[unit->type].name);
(void)rtEZRequestTags(foo,"Oh no!",NULL,NULL,
RT_Window, map_window,
RT_ReqPos, REQPOS_CENTERWIN,
RT_LockWindow, TRUE,
TAG_DONE);
FI
Remove((struct Node *)unit); // kill the plane
roster[unit->owner].ulc[unit->type]++;
control_flag = UNIT_LOST;
destruct_unit(unit);
if (PLAYER.show & SHOW_GRP)
explore_at_hex(player,targx,targy,VISIBLE,FALSE);
else
explore_at_hex(player,targx,targy,INVISIBLE,FALSE);
return (-3);
FI
FI
if (PLAYER.show & SHOW_GRP) {
unit_status_bar(unit);
explore_at_hex(player,targx,targy,VISIBLE,FALSE);
} else {
explore_at_hex(player,targx,targy,INVISIBLE,FALSE);
FI
if (cargo_killed==TRUE)
return (4);
return (0);
}
void build_move_menu()
{ // prepare the movement-mode menu for use
struct NewMenu new_menu_strip[] = {
{ NM_TITLE, "Project", NULL, NM_MENUDISABLED, NULL, NULL },
{ NM_ITEM, "Save Game", "S", ITEMTEXT, NULL, NULL },
{ NM_ITEM, "Save As...", NULL, ITEMTEXT, NULL, NULL },
{ NM_ITEM, NM_BARLABEL, NULL, ITEMTEXT, NULL, NULL },
{ NM_ITEM, "Exit Game", "X", ITEMTEXT, NULL, NULL },
{ NM_ITEM, "Quit Program", "Q", ITEMTEXT, NULL, NULL },
{ NM_TITLE, "Reports", NULL, NM_MENUDISABLED, NULL, NULL },
{ NM_ITEM, "World Map", NULL, ITEMTEXT, NULL, NULL },
{ NM_ITEM, "Status", NULL, ITEMTEXT, NULL, NULL },
{ NM_ITEM, "Combat Report", NULL, ITEMTEXT, NULL, NULL },
{ NM_ITEM, "Unit Info", NULL, ITEMTEXT, NULL, NULL },
{ NM_ITEM, "Production Map", NULL, ITEMTEXT, NULL, NULL },
{ NM_ITEM, "Ship Report", NULL, ITEMTEXT, NULL, NULL },
{ NM_ITEM, "Advisor's Recommendation", "Z", ITEMTEXT, NULL, NULL },
{ NM_TITLE, "Orders", NULL, NM_MENUDISABLED, NULL, NULL },
{ NM_ITEM, "Go Home H", NULL, ITEMTEXT, NULL, NULL },
{ NM_ITEM, "Go Direction *", NULL, ITEMTEXT, NULL, NULL },
{ NM_ITEM, "Go Random *", NULL, ITEMTEXT, NULL, NULL },
{ NM_ITEM, "Move To *", NULL, ITEMTEXT, NULL, NULL },
{ NM_ITEM, "Patrol To *", NULL, ITEMTEXT, NULL, NULL },
{ NM_ITEM, "Sentry S", NULL, ITEMTEXT, NULL, NULL },
{ NM_ITEM, "Clear Orders O", NULL, ITEMTEXT, NULL, NULL },
{ NM_ITEM, "Load Ship L", NULL, ITEMTEXT, NULL, NULL },
{ NM_ITEM, "Unload Ship U", NULL, ITEMTEXT, NULL, NULL },
{ NM_ITEM, "Skip Move [SPC]", NULL, ITEMTEXT, NULL, NULL },
{ NM_ITEM, "Escort Ship *", NULL, ITEMTEXT, NULL, NULL },
{ NM_TITLE, "Commands", NULL, NM_MENUDISABLED, NULL, NULL },
{ NM_ITEM, "Survey Mode V", NULL, ITEMTEXT, NULL, NULL },
{ NM_ITEM, "Wait W", NULL, ITEMTEXT, NULL, NULL },
{ NM_ITEM, "Cycle Stack 5", NULL, ITEMTEXT, NULL, NULL },
{ NM_ITEM, "Flight Paths *", NULL, ITEMTEXT, NULL, NULL },
{ NM_ITEM, "Center Screen C", NULL, ITEMTEXT, NULL, NULL },
{ NM_TITLE, "Other", NULL, NM_MENUDISABLED, NULL, NULL },
{ NM_ITEM, "Prefs", NULL, ITEMTEXT, NULL, NULL },
{ NM_ITEM, "Commanders", NULL, ITEMTEXT, NULL, NULL },
{ NM_ITEM, "View", NULL, ITEMTEXT, NULL, NULL },
{ NM_END, NULL, NULL, NULL, NULL, NULL }
};
if (!(move_menu_strip = CreateMenus(new_menu_strip,GTMN_FrontPen,BLACK,TAG_END)))
clean_exit(1,"ERROR: Unable to create menu strip for movement mode!");
if (!(LayoutMenus(move_menu_strip,vi,TAG_END)))
clean_exit(1,"ERROR: Unable to layout movement menus!");
}
void build_survey_menu()
{ // prepare the survey-mode menu for use
struct NewMenu new_menu_strip[] = {
{ NM_TITLE, "Project", NULL, NM_MENUDISABLED, NULL, NULL },
{ NM_ITEM, "Save Game", "S", ITEMTEXT, NULL, NULL },
{ NM_ITEM, "Save As...", NULL, ITEMTEXT, NULL, NULL },
{ NM_ITEM, NM_BARLABEL, NULL, ITEMTEXT, NULL, NULL },
{ NM_ITEM, "Exit Game", "X", ITEMTEXT, NULL, NULL },
{ NM_ITEM, "Quit Program", "Q", ITEMTEXT, NULL, NULL },
{ NM_TITLE, "Reports", NULL, NM_MENUDISABLED, NULL, NULL },
{ NM_ITEM, "World Map", NULL, ITEMTEXT, NULL, NULL },
{ NM_ITEM, "Status", NULL, ITEMTEXT, NULL, NULL },
{ NM_ITEM, "Combat Report", NULL, ITEMTEXT, NULL, NULL },
{ NM_ITEM, "Hex Info", NULL, ITEMTEXT, NULL, NULL },
{ NM_ITEM, "Production Map", NULL, ITEMTEXT, NULL, NULL },
{ NM_ITEM, "Ship Report", NULL, ITEMTEXT, NULL, NULL },
{ NM_TITLE, "Orders", NULL, NM_MENUDISABLED, NULL, NULL },
{ NM_ITEM, "Clear Orders O", NULL, ITEMTEXT, NULL, NULL },
{ NM_ITEM, "Cycle Stack 5", NULL, ITEMTEXT, NULL, NULL },
{ NM_ITEM, "Activate A", NULL, ITEMTEXT, NULL, NULL },
{ NM_TITLE, "Commands", NULL, NM_MENUDISABLED, NULL, NULL },
{ NM_ITEM, "Move Mode M", NULL, ITEMTEXT, NULL, NULL },
{ NM_ITEM, "Group Survey *", NULL, ITEMTEXT, NULL, NULL },
{ NM_ITEM, "Flight Paths *", NULL, ITEMTEXT, NULL, NULL },
{ NM_ITEM, "Center Screen C", NULL, ITEMTEXT, NULL, NULL },
{ NM_TITLE, "Other", NULL, NM_MENUDISABLED, NULL, NULL },
{ NM_ITEM, "Prefs", NULL, ITEMTEXT, NULL, NULL },
{ NM_ITEM, "Commanders", NULL, ITEMTEXT, NULL, NULL },
{ NM_ITEM, "View", NULL, ITEMTEXT, NULL, NULL },
{ NM_END, NULL, NULL, NULL, NULL, NULL }
};
if (!(vey_menu_strip = CreateMenus(new_menu_strip,GTMN_FrontPen,BLACK,TAG_END)))
clean_exit(1,"ERROR: Unable to create menu strip for survey mode!");
if (!(LayoutMenus(vey_menu_strip,vi,TAG_END)))
clean_exit(1,"ERROR: Unable to layout survey menus!");
}
void build_production_menu()
{ // prepare the production-mode menu for use
struct NewMenu new_menu_strip[] = {
{ NM_TITLE, "Project", NULL, NM_MENUDISABLED, NULL, NULL },
{ NM_ITEM, "Save Game", "S", ITEMTEXT, NULL, NULL },
{ NM_ITEM, "Save As...", NULL, ITEMTEXT, NULL, NULL },
{ NM_ITEM, NM_BARLABEL, NULL, ITEMTEXT, NULL, NULL },
{ NM_ITEM, "Exit Game", "X", ITEMTEXT, NULL, NULL },
{ NM_ITEM, "Quit Program", "Q", ITEMTEXT, NULL, NULL },
{ NM_TITLE, "Reports", NULL, NM_MENUDISABLED, NULL, NULL },
{ NM_ITEM, "World Map", NULL, ITEMTEXT, NULL, NULL },
{ NM_ITEM, "Status", NULL, ITEMTEXT, NULL, NULL },
{ NM_ITEM, "Ship Report", NULL, ITEMTEXT, NULL, NULL },
{ NM_TITLE, "Commands", NULL, NM_MENUDISABLED, NULL, NULL },
{ NM_ITEM, "Examine City [Enter]", NULL, ITEMTEXT, NULL, NULL },
{ NM_ITEM, "Move Mode M", NULL, ITEMTEXT, NULL, NULL },
{ NM_ITEM, "Survey Mode V", NULL, ITEMTEXT, NULL, NULL },
{ NM_ITEM, "Center Screen C", NULL, ITEMTEXT, NULL, NULL },
{ NM_TITLE, "Other", NULL, NM_MENUDISABLED, NULL, NULL },
{ NM_ITEM, "Prefs", NULL, ITEMTEXT, NULL, NULL },
{ NM_ITEM, "Commanders", NULL, ITEMTEXT, NULL, NULL },
{ NM_ITEM, "View", NULL, ITEMTEXT, NULL, NULL },
{ NM_END, NULL, NULL, NULL, NULL, NULL }
};
if (!(prod_menu_strip = CreateMenus(new_menu_strip,GTMN_FrontPen,BLACK,TAG_END)))
clean_exit(1,"ERROR: Unable to create menu strip for production mode!");
if (!(LayoutMenus(prod_menu_strip,vi,TAG_END)))
clean_exit(1,"ERROR: Unable to layout production menus!");
}
/*
Give orders to a unit. Note that some of these values (namely destx, desty
and etc) may be set by the calling function or may be set by give_orders(),
depending on the specifics of the order being given.
This function does NOT actually process the order, but leaves that to the
order manager to take care of later.
*/
void give_orders(unit,token,destx,desty,etc)
struct Unit *unit;
int token, destx, desty, etc;
{
struct Order *order=AllocVec((long)sizeof(*order),MEMF_CLEAR);
struct City* metro = (struct City *)city_list.mlh_Head;
struct City* closest = NULL;
struct Unit* lookunit = (struct Unit *)unit_list.mlh_Head;
struct Unit* nearest = NULL;
char askstring[80];
clear_orders(unit);
if (order) {
unit->orders = order;
order->type = token;
order->orgx = unit->col;
order->orgy = unit->row;
order->processed = FALSE;
switch (token) {
case ORDER_SENTRY:
case ORDER_LOAD:
order->destx = unit->col;
order->desty = unit->row;
order->etc = -1;
break;
case ORDER_GOTO:
// Check for an aircraft and a possible target carrier
// Only FIGHTERS can land on carriers now.
if( (unit->type == FIGHTER) //||
//(unit->type == BOMBER) ||
//(unit->type == AIRCAV)
) {
for (; lookunit->unode.mln_Succ; lookunit =
(struct Unit *)lookunit->unode.mln_Succ)
if( (lookunit->owner==player) &&
(lookunit->type == CARRIER) &&
(lookunit->col == destx) &&
(lookunit->row == desty) ) {
// Ask user if he wants it to land on the carrier
sprintf( askstring, "Land aircraft on Carrier %s?",
lookunit->name);
if (rtEZRequestTags(askstring,"Yes|No",
NULL,NULL, RTEZ_Flags,EZREQF_CENTERTEXT,
RT_Window,map_window,RT_ReqPos,
REQPOS_CENTERWIN,RT_LockWindow,TRUE,TAG_END )) {
order->dest_unit = lookunit;
order->etc = etc;
break;
}
}
// End for loop
}
order->destx = destx;
order->desty = desty;
order->etc = etc;
break;
case ORDER_PATROL:
order->destx = destx;
order->desty = desty;
order->etc = -etc;
order->type = ORDER_GOTO; /* Important - no token for PATROL */
break;
case ORDER_HOME:
/* Need to find the closest city or carrier we can land on */
for ( ; metro->cnode.mln_Succ; metro =
(struct City *)metro->cnode.mln_Succ)
if(metro->owner==player) {
if( !closest ) closest = metro;
else {
if( AI5_GetDist ( unit->col, unit->row,
metro->col, metro->row ) < AI5_GetDist
(unit->col, unit->row, closest->col,
closest->row) ) closest = metro;
}
}
/* End for */
/* Verify the vs. our fuel if applicable, then look for a
carrier. */
if( (unit->type == FIGHTER) || (unit->type == BOMBER) ||
(unit->type == AIRCAV) ) {
/* if the city is too far away, forget it */
if( (closest) &&( AI5_GetDist
(unit->col, unit->row, closest->col, closest->row) >
unit->fuel ) ) closest = NULL;
/* Look for the closest carrier */
for (; lookunit->unode.mln_Succ; lookunit =
(struct Unit *)lookunit->unode.mln_Succ)
if( (lookunit->owner==player) &&
(lookunit->type == CARRIER) ) {
if( !nearest ) nearest = lookunit;
else {
if( AI5_GetDist ( unit->col, unit->row,
lookunit->col, lookunit->row ) <
AI5_GetDist (unit->col, unit->row,
nearest->col, nearest->row) )
nearest = lookunit;
}
}
/* End for */
/* Do we have a carrier? If so, is it in range? If not,
forget it. */
if( (nearest) && (AI5_GetDist
(unit->col, unit->row, nearest->col, nearest->row) >
unit->fuel ) ) nearest = NULL;
/* Any place to land? */
if( (nearest == NULL) && (closest == NULL) ) {
clear_orders( unit );
break;
}
/* Now, do we have a carrier that is closer? If not, forget
it and go with the city. */
if( (nearest ) && (closest) ) {
if( AI5_GetDist
(unit->col, unit->row, nearest->col, nearest->row) >=
AI5_GetDist
(unit->col, unit->row, closest->col, closest->row) )
nearest = NULL;
}
}
/* Check them for fuel vs. aircraft - no sense heading for
someplace we can't reach. */
//order->etc = etc;
order->type = ORDER_GOTO; /* Important - no token for HOME */
/* Go for the carrier first */
if( nearest ) {
order->dest_unit = nearest;
order->etc = AI5_GetDist(unit->col, unit->row,
order->dest_unit->col, order->dest_unit->row);
}
else {
if( closest) {
order->destx = closest->col;
order->desty = closest->row;
order->etc = AI5_GetDist(unit->col, unit->row,
order->destx, order->desty);
}
else {
/* Nowhere to go */
clear_orders( unit );
}
}
break;
}
}
}
/*
the purpose of shuffle_units() is to shuffle the current unit in a hex
to the bottom of the pile, and activate the next valid one beneath it
parameter is the current top unit; return value is the new top unit
*/
struct Unit *shuffle_units(topunit, survey)
struct Unit *topunit;
BOOL survey; // indicates whether we are in survey mode
{
struct Unit *newunit = (struct Unit *)unit_list.mlh_Head;
int col=topunit->col, row=topunit->row;
for (; newunit->unode.mln_Succ; newunit=(struct Unit *)newunit->unode.mln_Succ)
if (newunit->col==col && newunit->row==row && newunit!=topunit)
if (Bool(unit_readiness(newunit)&UNIT_READY) || survey) {
// move this unit to the beginning of list
Remove((struct Node *)newunit);
AddHead((struct List *)&unit_list,(struct Node *)newunit);
// move the old unit to the end of the list
Remove((struct Node *)topunit);
AddTail((struct List *)&unit_list,(struct Node *)topunit);
return newunit;
FI
return topunit;
}
void start_blinking_unit(unit)
struct Unit *unit;
{ // display the unit to be moved, set up blinking graphics
int col = unit->col, row = unit->row;
struct City *metro = (struct City *)city_list.mlh_Head;
BOOL stacked=(count_units_at(unit->col,unit->row)>1);
int token;
// draw in the background terrain
plot_hex(col,row,get(t_grid,col,row));
if (get_flags(PLAYER.map,col,row)&ROAD)
GP_draw_roads(col,row);
// if there is a city here, draw it
for ( ; metro->cnode.mln_Succ; metro = (struct City*)metro->cnode.mln_Succ)
if (metro->col==col && metro->row==row)
plot_city(col,row,roster[metro->owner].color,FALSE);
// if the unit is on board a ship, draw the ship as background
if (unit->ship) {
token = ORDER_NONE;
if (unit->ship->orders)
token=unit->ship->orders->type;
plot_icon(unit->ship->type,col,row,roster[unit->owner].color,token,TRUE);
FI
// store this background in a safe place (buffer 0)
save_hex_graphics(col,row,0);
// plot the unit icon
token = ORDER_NONE;
if (unit->orders)
token = unit->orders->type;
plot_icon(unit->type,col,row,roster[unit->owner].color,token,stacked);
// just make sure the map icon matches what I'm displaying
// otherwise things like order tokens might disappear or be wrong
explore_hex(unit->owner,unit->col,unit->row,INVISIBLE,TRUE);
}
void movement_mode(current_unit)
struct Unit **current_unit;
{
struct IntuiMessage *message; // the message the IDCMP sends us
struct Unit *unit = *current_unit;
unsigned int ticks = 1;
BOOL blink_on = TRUE;
BOOL stacked;
// useful for interpreting IDCMP messages
UWORD code;
ULONG class;
APTR object;
if (unit)
stacked = (count_units_at(unit->col,unit->row)>1);
/*
If there is no map display, this is the right time to create one.
but first set COL and ROW to default values, searching for a city
belonging to the player...
*/
if (unit==NULL && display==FALSE) {
struct City *metro=(struct City *)city_list.mlh_Head;
for (; metro->cnode.mln_Succ; metro=(struct City *)metro->cnode.mln_Succ)
if (metro->owner==player) {
cursx=metro->col; cursy=metro->row;
create_player_display(cursx,cursy);
break;
FI
} else if (unit)
create_player_display(unit->col,unit->row);
/*
If the value "unit" passed to movement_mode() is NULL, this signifies that
the player has no more units left to move. So, we must ask him if he wants
to continue, then dump him back to the mode manager. If he wants to
continue, we set GO_SURVEY so he is sent to survey mode. Otherwise we
set END_TURN so the manager knows to exit out.
*/
if (unit==NULL) {
control_flag = (rtEZRequestTags(\
"All your units have moved.\nDo you wish to continue?",
" End Turn |Review Map", NULL, NULL,
RT_Window, map_window,
RT_ReqPos, REQPOS_CENTERSCR,
RT_LockWindow, TRUE,
RT_ShareIDCMP, TRUE,
RTEZ_Flags, EZREQF_CENTERTEXT,
TAG_DONE
)?END_TURN:GO_SURVEY);
return;
FI
if (display==FALSE) {
set_display_offsets(unit->col,unit->row);
GP_draw_map();
} else if (need_to_scrollP(unit->col,unit->row)) {
int ox=xoffs, oy=yoffs;
set_display_offsets(unit->col,unit->row);
GP_smart_scroll(ox,oy);
FI
// clear orders
if (unit->orders) {
clear_orders(unit);
GP_update_hex_display(unit->col,unit->row);
FI
start_blinking_unit(unit);
unit_status_bar(unit);
// activate IDCMP event input
ModifyIDCMP(map_window,IDCMP_PLAYGAME);
// attach the menu to my window
SetMenuStrip(map_window,move_menu_strip);
// Enable menus
OnMenu(map_window,FULLMENUNUM(0,NOITEM,0));
OnMenu(map_window,FULLMENUNUM(1,NOITEM,0));
OnMenu(map_window,FULLMENUNUM(2,NOITEM,0));
OnMenu(map_window,FULLMENUNUM(3,NOITEM,0));
OnMenu(map_window,FULLMENUNUM(4,NOITEM,0));
control_flag = 0; // flag lets me know when unit is done
/*
This is the most important user input loop of the whole game, where
I get the movement of the current unit, let the user scroll around,
select various options from the drop-down menus, etc.
*/
while (TRUE) {
WaitPort(map_window->UserPort);
while (message = GT_GetIMsg(map_window->UserPort)) {
code = message->Code; // MENUNUM
object = message->IAddress; // Gadget
class = message->Class;
GT_ReplyIMsg(message);
if ( class == MENUPICK ) { // MenuItems
ClearMenuStrip(map_window);
switch (MENUNUM(code)) {
case 0: // Project menu
switch (ITEMNUM(code)) {
case 0: // save game
{
char pan[216];
build_pan(pan,game_filepath,game_filename);
save_game(pan);
}
break;
case 1: // save as...
(void)rt_loadsave_game(TRUE);
break;
case 3: // exit game
if (alert(map_window,"Exit this game.","Are you sure you want to abandon this game now?","Exit|Cancel")) {
control_flag = EXIT_GAME;
return;
FI
break;
case 4: // quit program
if (alert(map_window,"Exit Invasion Force.","You have a game in progress.\nAre you sure you want to leave Invasion Force now?","Exit|Cancel"))
clean_exit(0,NULL);
break;
default:
(void)rtEZRequestTags("That function is not yot implemented.","Drat!",NULL,NULL,
RT_DEFAULT,TAG_END);
}
break;
case 1: // Reports menu
switch (ITEMNUM(code)) {
case 0: // World Map
GP_world_view();
break;
case 1: // Status report
status_report(player);
break;
case 2: // Combat Report
restore_hex_graphics(unit->col,unit->row,0);
show_combat_report(FALSE);
if (need_to_scrollP(unit->col,unit->row)) {
int ox=xoffs, oy=yoffs;
set_display_offsets(unit->col,unit->row);
GP_smart_scroll(ox,oy);
FI
start_blinking_unit(unit);
break;
case 4: // Production Map
control_flag = GO_PRODUCTION;
break;
case 6: // Advisor's Recommendation
class = IDCMP_VANILLAKEY;
code = 'z';
break;
}
break;
case 2: // Orders menu
switch (ITEMNUM(code)) {
case 0: // Home
class = IDCMP_VANILLAKEY;
code = 'h';
break;
case 5: // Sentry
class = IDCMP_VANILLAKEY;
code = 's';
break;
case 6: // Clear Orders
class = IDCMP_VANILLAKEY;
code = 'o';
break;
case 7: // Load Ship
class = IDCMP_VANILLAKEY;
code = 'l';
break;
case 8: // Unload Ship
class = IDCMP_VANILLAKEY;
code = 'u';
break;
case 9: // Skip Move
class = IDCMP_VANILLAKEY;
code = ' ';
break;
default:
(void)rtEZRequestTags("That function is not yot implemented.","Drat!",NULL,NULL,
RT_DEFAULT,TAG_END);
}
break;
case 3: // Commands Menu
switch (ITEMNUM(code)) {
case 0: // Survey Mode
class = IDCMP_VANILLAKEY;
code = 'v';
break;
case 1: // Wait
class = IDCMP_VANILLAKEY;
code = 'w';
break;
case 2: // Cycle Stack
class = IDCMP_VANILLAKEY;
code = '5';
break;
case 4: // Center Screen
class = IDCMP_VANILLAKEY;
code = 'c';
break;
}
break;
case 4: // Other Menu
if (ITEMNUM(code)==0)
player_preferences();
};
FI
// following are key commands available in movement mode
if (class==IDCMP_VANILLAKEY) {
switch (code) {
int direction;
case 'q':
{ // Special function to turn on and off AI information
ToggleAIDataFlag();
break;
}
case 'z':
{ // New Military Advisor function
int response1 = 0, response2 = 0;
int recommend = AI5_recommend_action( unit, 40, 60 );
if( (recommend >= 0) && (recommend <= 5) ) {
sprintf( foo, "Advisor recommends a move %s",
DirString[recommend] );
response1 = rtEZRequestTags
(foo,"Do it|Show Details|Cancel",
NULL,NULL,
RT_Window, map_window,
RT_ReqPos, REQPOS_CENTERSCR,
RT_LockWindow, TRUE,
RTEZ_Flags, EZREQF_CENTERTEXT,
TAG_DONE );
} // End if we have a recommendation
else {
response2 = rtEZRequestTags
("The Advisor has no recommended move for that unit.",
"Show Details|OK",NULL,NULL, RT_DEFAULT,TAG_END);
}
if ( response1 == 1) {
// Taking the advice. Let's do it then
direction = recommend;
goto mm_moving;
}
if ( (response1 == 2) || (response2 == 1) ) {
// Go through each hex in turn and give him raw data
int index;
struct HexReport rep;
for( index=0; index<6; index++ ) {
/* Fill in the raw data */
short targx, targy;
if (AI1_calc_dir (index, unit->col, unit->row,
&targx, &targy) != -1) {
AI5_evaluate_hex( unit, targx, targy,
&rep );
}
if( rep.CanAttack || rep.AtRisk ) {
if( unit->name ) {
sprintf( foo,
"%s of %s %s\nAre %ld enemy unit(s) valued at %ld\nThe value of your %ld unit(s) is %ld\nThe odds of winning are %ld %%",
DirString[index], unit->name,
wishbook[unit->type].name,
rep.TotalEUnits, rep.Gain,
rep.TotalMyUnits, rep.Risk,
rep.Odds );
(void) rtEZRequestTags
(foo,"OK",
NULL,NULL,
RT_Window, map_window,
RT_ReqPos, REQPOS_CENTERSCR,
RT_LockWindow, TRUE,
RTEZ_Flags, EZREQF_CENTERTEXT,
TAG_DONE );
}
else {
sprintf( foo,
"%s of your %s\nAre %ld enemy unit(s) valued at %ld\nThe value of your %ld unit(s) is %ld\nThe odds of winning are %ld %%",
DirString[index],
wishbook[unit->type].name,
rep.TotalEUnits, rep.Gain,
rep.TotalMyUnits, rep.Risk,
rep.Odds );
(void) rtEZRequestTags
(foo,"OK",
NULL,NULL,
RT_Window, map_window,
RT_ReqPos, REQPOS_CENTERSCR,
RT_LockWindow, TRUE,
RTEZ_Flags, EZREQF_CENTERTEXT,
TAG_DONE );
} // End else no name
} // End if CanAttack or AtRisk
} // End for loop
} // End if response
} // End case 'z'
break;
case 'c':
{ // center the display on the current unit icon
int ox = xoffs, oy = yoffs;
restore_hex_graphics(unit->col,unit->row,0);
set_display_offsets(unit->col,unit->row);
GP_smart_scroll(ox,oy);
if (blink_on)
plot_icon(unit->type,unit->col,unit->row,roster[unit->owner].color,ORDER_NONE,stacked);
}
break;
case 'w': // Wait for unit (put at end of unit list
Remove((struct Node*)unit);
AddTail((struct List*)&unit_list,(struct Node*)unit);
/* And set the control flag so we don't try to do
anything else with this unit. */
restore_hex_graphics(unit->col,unit->row,0);
plot_icon(unit->type,unit->col,unit->row,
roster[unit->owner].color,ORDER_NONE,stacked);
control_flag = UNIT_LOST;
break;
case ' ': // skip this turn
// airplanes not moving still use fuel!
if( (wishbook[unit->type].range>0 ) && (
!(city_hereP(unit->col,unit->row))) &&
(unit->ship == NULL) ) { // added last factor trying to
// fix bug - when carrier moves with aircraft on board
// the aircraft lose fuel.
unit->fuel -= unit->move/60;
// Add a check for out of fuel
if (unit->fuel<=0) {
// aircraft out of fuel, crashes!
if (PLAYER.show & SHOW_REQ) {
plot_mapobject(unit->col,unit->row,154,30); // explosion
context_sound(BOOM_SOUND); // kaboomy!
// now tell the player the awful news
sprintf(foo,"Your %s has run out of fuel and crashed!",
wishbook[unit->type].name);
(void)rtEZRequestTags(foo,"Oh no!",NULL,NULL,
RT_Window, map_window,
RT_ReqPos, REQPOS_CENTERWIN,
RT_LockWindow, TRUE,
TAG_DONE);
}
Remove((struct Node *)unit); // kill the plane
roster[unit->owner].ulc[unit->type]++;
control_flag = UNIT_LOST;
destruct_unit(unit);
if (PLAYER.show & SHOW_REQ)
explore_at_hex(player,unit->col,unit->row,VISIBLE,FALSE);
else
explore_at_hex(player,unit->col,unit->row,INVISIBLE,FALSE);
} // End if fuel out
}
// damaged units in a city may be repaired
if (unit->damage>0 && unit->move>50 && city_hereP(unit->col ,unit->row))
unit->damage--;
unit->move = 0;
control_flag = UNIT_DONE;
break;
case 'n': // move on to next unit
// move unit to the tail end of the master unit list
Remove((struct Node *)unit);
AddTail((struct List *)&unit_list,(struct Node *)unit);
*current_unit = choose_default_unit(unit);
control_flag = UNIT_DONE;
break;
case 'h': /* head for home */
restore_hex_graphics(unit->col,unit->row,0);
plot_icon(unit->type,unit->col,unit->row,
roster[unit->owner].color,ORDER_GOTO,stacked);
give_orders(unit, ORDER_HOME, 0, 0, -1);
if( unit->orders)
unit->orders->processed = FALSE;
else
plot_icon(unit->type,unit->col,unit->row,
roster[unit->owner].color,ORDER_NONE,stacked);
control_flag = UNIT_DONE;
break;
case 's': /* unit for sentry duty */
// units that need fuel (i.e. aircraft) cannot sentry,
// except in cities or on aircraft carriers
if (wishbook[unit->type].range>0)
if (unit->ship==NULL && city_hereP(unit->col,unit->row)==NULL) {
playSound(DONK_SOUND,PLAYER.snd_vol);
break; // we bail
FI
give_orders(unit,ORDER_SENTRY,0,0,-1);
explore_hex(player,unit->col,unit->row,VISIBLE,FALSE);
control_flag = UNIT_DONE;
break;
case 'l': // load ship
if (cargo_capacity(unit)<0) {
tell_user2("That unit is not a cargo vessel.",FALSE,DONK_SOUND);
break;
FI
if (unit->cargo>=cargo_capacity(unit) ||
unit->weight>=cargo_capacity(unit)) {
playSound(DONK_SOUND,PLAYER.snd_vol);
(void)rtEZRequestTags("That ship seems to be full,\nand cannot load more units.",
"Okay",NULL,NULL,
RT_Window, map_window,
RT_ReqPos, REQPOS_CENTERSCR,
RT_LockWindow, TRUE,
RTEZ_Flags, EZREQF_CENTERTEXT,
TAG_DONE );
break;
FI
give_orders(unit,ORDER_LOAD,0,0,0);
load_ship(unit); // do it right away, if possible
start_blinking_unit(unit); //*** so icon in buffer is
// updated ***/
if (unit->orders) { // unit still not full
unit->orders->processed = TRUE;
control_flag = UNIT_DONE;
} break;
case 'u': // unload ship (clears orders of anything on board)
if (unit->cargo>0) {
struct Unit *cargo=(struct Unit *)unit_list.mlh_Head;
for (;cargo->unode.mln_Succ;cargo=(struct Unit *)cargo->unode.mln_Succ)
if (cargo->ship==unit)
clear_orders(cargo);
FI
break;
case 'v':
control_flag = GO_SURVEY;
break;
case '5': // cycle or shuffle stack to next unit
{
struct Unit *newunit=shuffle_units(unit,FALSE);
if (newunit!=unit) {
*current_unit = newunit;
control_flag = UNIT_DONE;
break;
} else
if( PLAYER.soundfx == SOUND_ALL )
playSound(DONK_SOUND,PLAYER.snd_vol);
}
break;
// following is a sort of movement table, translates
// keypad numbers into movement directions
case '6':
direction = EAST;
goto mm_moving;
case '4':
direction = WEST;
goto mm_moving;
case '7':
direction = NORTHWEST;
goto mm_moving;
case '9':
direction = NORTHEAST;
goto mm_moving;
case '1':
direction = SOUTHWEST;
goto mm_moving;
case '3':
direction = SOUTHEAST;
mm_moving:
{
int orgx=unit->col, orgy=unit->row;
// use orgx and orgy to track actual (not requested) movement
// of unit, so we can keep the blinking icon working right
restore_hex_graphics(unit->col,unit->row,0);
move_unit_dir(unit,direction);
// if the control flag is set for any reason, it means
// we are outta here; no need to reinstate blinking
if (control_flag)
break;
// if the unit has actually moved, we certainly
// need to reinstate the blinking icon
if (orgx!=unit->col || orgy!=unit->row) {
stacked = (count_units_at(unit->col,unit->row)>1);
start_blinking_unit(unit);
} else
if (blink_on) /* didn't move: continue blinking normally */
plot_icon(unit->type,unit->col,unit->row,roster[unit->owner].color,ORDER_NONE,stacked);
}
break;
default:
(void)rtEZRequestTags("That key has no defined function.\nPlease try one of the many other keys.",
"Okay",NULL,NULL,
RT_Window, map_window,
RT_ReqPos, REQPOS_CENTERSCR,
RT_LockWindow, TRUE,
RTEZ_Flags, EZREQF_CENTERTEXT,
TAG_DONE );
} // end switch
FI
if (class==IDCMP_MOUSEBUTTONS && code==SELECTDOWN) {
int x, y, ctr=0, orgx=unit->col, orgy=unit->row;
int num_hexes=adjacent(unit->col,unit->row);
abs_to_log(message->MouseX,message->MouseY,&x,&y);
for (; ctr<num_hexes; ctr++)
if (hexlist[ctr].col==x && hexlist[ctr].row==y) {
// use orgx and orgy to track actual (not requested) movement
// of unit, so we can keep the blinking icon working right
restore_hex_graphics(unit->col,unit->row,0);
move_unit_xy(unit,x,y);
// if the control flag is set for any reason, it means
// we are outta here; no need to reinstate blinking
if (control_flag)
break;
// if the unit has actually moved, we certainly
// need to reinstate the blinking icon
if (orgx!=unit->col || orgy!=unit->row) {
stacked = (count_units_at(unit->col,unit->row)>1);
start_blinking_unit(unit);
} else
if (blink_on) /* didn't move: continue blinking normally */
plot_icon(unit->type,unit->col,unit->row,roster[unit->owner].color,ORDER_NONE,stacked);
break; // no need for extra iterations after we found our hex
FI
//ROF
if( ctr == num_hexes ) {
/* There was not a match for the hexes immediately around
** the unit. So, let's invoke a GOTO command for that
** unit. x and y contain the coordinates of the hex
** the user selected.
*/
AI5_CalcPath( unit->type, unit->col, unit->row, x, y,
AI5_PATH_GOOD);
if( Path[0] != -1 ) {
if( (wishbook[unit->type].range > 0) &&
(unit->fuel < PathLength) ) {
// We haven't got enough fuel to reach it
sprintf( foo,
"Can't reach from %ld,%ld to %ld,%ld, %s .",
unit->col, unit->row, x, y,
"\nNot enough fuel!");
(void)rtEZRequestTags
(foo,"Darn!",NULL,NULL,
RT_Window, map_window,
RT_ReqPos, REQPOS_CENTERSCR,
RT_LockWindow, TRUE,
RTEZ_Flags, EZREQF_CENTERTEXT,
TAG_DONE );
} // End if we haven't enough fuel
else {
int response;
int ETA = 1;
// We have a path, so verify the orders
// *** Add path drawing here ***
PathCost -= unit->move;
while (PathCost > 0) {
ETA++;
PathCost -= unit_speed(unit);
}
if( unit->name ) {
sprintf( foo,
"Move %s %s from %ld,%ld to %ld,%ld\nDistance is %ld\nPath length is %ld\nETA is %ld turns",
UnitString[unit->type],
unit->name, unit->col, unit->row, x, y,
AI5_GetDist(unit->col, unit->row, x, y),
PathLength,ETA);
}
else {
sprintf( foo,
"Move %s from %ld,%ld to %ld,%ld\nDistance is %ld\nPath length is %ld\nETA is %ld turns",
UnitString[unit->type],
unit->col, unit->row, x, y,
AI5_GetDist(unit->col, unit->row, x, y),
PathLength,ETA);
}
response = rtEZRequestTags
(foo,"OK|Patrol|Cancel",NULL,NULL,
RT_Window, map_window,
RT_ReqPos, REQPOS_CENTERSCR,
RT_LockWindow, TRUE,
RTEZ_Flags, EZREQF_CENTERTEXT,
TAG_DONE );
if (response == 1) {
restore_hex_graphics(unit->col,unit->row,0);
plot_icon(unit->type,unit->col,unit->row,
roster[unit->owner].color,ORDER_GOTO,stacked);
give_orders(unit,ORDER_GOTO,x,y,PathLength);
unit->orders->processed = FALSE;
control_flag = UNIT_DONE;
}
if (response == 2) {
// Patrol looks the same except the order type
plot_icon(unit->type,unit->col,unit->row,
roster[unit->owner].color,ORDER_GOTO,stacked);
give_orders(unit,ORDER_PATROL,x,y,PathLength);
unit->orders->processed = FALSE;
control_flag = UNIT_DONE;
}
// *** Erase path drawn here ***
} // End else we have a path and enough fuel
} // End if we have a path
else {
// No path at all
sprintf( foo,
"Can't find a path from %ld,%ld to %ld,%ld .",
unit->col, unit->row, x, y);
if( wishbook[unit->type].range > 0 ) {
strcat( foo,
"\nOr path length exceeds range of aircraft." );
}
(void)rtEZRequestTags
(foo,"Darn!",NULL,NULL,
RT_Window, map_window,
RT_ReqPos, REQPOS_CENTERSCR,
RT_LockWindow, TRUE,
RTEZ_Flags, EZREQF_CENTERTEXT,
TAG_DONE );
} // End else no path at all
break;
FI
FI
if (class==IDCMP_GADGETUP) {
int ox = xoffs, oy = yoffs;
restore_hex_graphics(unit->col,unit->row,0);
if (scrolly(object,code)) {
GP_smart_scroll(ox,oy);
FI
if (blink_on)
plot_icon(unit->type,unit->col,unit->row,roster[unit->owner].color,ORDER_NONE,stacked);
FI
if (class == IDCMP_INTUITICKS) // intuiticks control blinking
if ((++ticks % 5) == 0) {
blink_on = !blink_on;
if (blink_on)
plot_icon(unit->type,unit->col,unit->row,roster[unit->owner].color,ORDER_NONE,stacked);
else
restore_hex_graphics(unit->col,unit->row,0);
FI
ResetMenuStrip(map_window,move_menu_strip);
switch (control_flag) {
case UNIT_DONE:
case UNIT_LOST:
case GO_SURVEY:
case GO_PRODUCTION:
goto xyzzy; // this should be "break 3;" but C makes it hard
} // end switch
OD
OD
xyzzy:
// here is everything I need to clean up leaving movement mode
if (control_flag==UNIT_LOST)
unit=NULL;
if (unit)
GP_update_hex_display(unit->col,unit->row);
// deactivate IDCMP event input
ModifyIDCMP(map_window,NULL);
// so that survey mode can pick up in the same spot
if (unit) {
cursx = unit->col;
cursy = unit->row;
FI
// always clear the unit movement bar
clear_movebar();
/* return to my "generic" title bar, so no outdated information is */
/* seen when it shouldn't be -- especially by the next player! */
SetWindowTitles(map_window,"Game in progress...",(UBYTE *)~0);
}
void plot_cursor(x,y)
int x,y;
{
int px, py;
// plot the cursor; grafx_bitmap coords 242,30
log_to_abs(x,y,&px,&py);
px += 5; py += 8; // centering it in the hexagon
BltBitMapRastPort(&grafx_bitmap,242,30,rast_port,px,py,21,17,0x0C0);
}
// move cursor in the specified direction, if possible
void move_cursor_dir(dir)
int dir;
{
int targx = cursx, targy = cursy;
switch (dir) {
case EAST:
targx++;
break;
case WEST:
targx--;
break;
case NORTHEAST:
targy--;
if (cursy%2) // odd number
targx++;
break;
case NORTHWEST:
targy--;
if (!(cursy%2)) // even number
targx--;
break;
case SOUTHEAST:
targy++;
if (cursy%2) // odd number
targx++;
break;
case SOUTHWEST:
targy++;
if (!(cursy%2)) // even number
targx--;
break;
default:
return;
}
/* correct values for wrap, if it's active */
if (wrap) {
if (targx<0)
targx += width;
if (targx>width)
targx -= width;
if (targy<0)
targy += height;
if (targy>height)
targy -= height;
}
if (targx<0 || targx>(width-1))
return;
if (targy<0 || targy>(height-1))
return;
cursx = targx;
cursy = targy;
}
// end of listing